/*
 * Copyright 2008-2010, Axel Dörfler. All Rights Reserved.
 * Copyright 2007, Hugo Santos. All Rights Reserved.
 *
 * Distributed under the terms of the MIT License.
 */
#ifndef OBJECT_CACHE_H
#define OBJECT_CACHE_H


#include <condition_variable.h>
#include <lock.h>
#include <slab/Slab.h>
#include <util/DoublyLinkedList.h>

#include "ObjectDepot.h"
#include "slab_queue.h"

#include "kernel_debug_config.h"
#include "slab_debug.h"


struct ResizeRequest;


struct slab : DoublyLinkedListLinkImpl<slab> {
        void*                   pages;
        size_t                  size;           // total number of objects
        size_t                  count;          // free objects
        size_t                  offset;
        slab_queue              free;
#if SLAB_OBJECT_CACHE_ALLOCATION_TRACKING
        AllocationTrackingInfo* tracking;
#endif
};

typedef DoublyLinkedList<slab> SlabList;

struct ObjectCacheResizeEntry {
        ConditionVariable       condition;
        thread_id                       thread;
};

struct ObjectCache : DoublyLinkedListLinkImpl<ObjectCache> {
                        char                            name[32];
                        mutex                           lock;
                        size_t                          object_size;
                        size_t                          alignment;
                        size_t                          cache_color_cycle;
                        SlabList                        empty;
                        SlabList                        partial;
                        SlabList                        full;
                        size_t                          total_objects;          // total number of objects
                        size_t                          used_count;                     // used objects
                        size_t                          empty_count;            // empty slabs
                        size_t                          pressure;
                        size_t                          min_object_reserve;
                                                                        // minimum number of free objects

                        size_t                          slab_size;
                        size_t                          usage;
                        size_t                          maximum;
                        uint32                          flags;

                        ResizeRequest*          resize_request;

                        ObjectCacheResizeEntry* resize_entry_can_wait;
                        ObjectCacheResizeEntry* resize_entry_dont_wait;

                        DoublyLinkedListLink<ObjectCache> maintenance_link;
                        bool                            maintenance_pending;
                        bool                            maintenance_in_progress;
                        bool                            maintenance_resize;
                        bool                            maintenance_delete;

                        void*                           cookie;
                        object_cache_constructor constructor;
                        object_cache_destructor destructor;
                        object_cache_reclaimer reclaimer;

                        object_depot            depot;

public:
        virtual                                         ~ObjectCache();

                        status_t                        Init(const char* name, size_t objectSize,
                                                                        size_t alignment, size_t maximum,
                                                                        size_t magazineCapacity,
                                                                        size_t maxMagazineCount, uint32 flags,
                                                                        void* cookie,
                                                                        object_cache_constructor constructor,
                                                                        object_cache_destructor destructor,
                                                                        object_cache_reclaimer reclaimer);
        virtual void                            Delete() = 0;

        virtual slab*                           CreateSlab(uint32 flags) = 0;
        virtual void                            ReturnSlab(slab* slab, uint32 flags) = 0;
        virtual slab*                           ObjectSlab(void* object) const = 0;

                        slab*                           InitSlab(slab* slab, void* pages,
                                                                        size_t byteCount, uint32 flags);
                        void                            UninitSlab(slab* slab);

                        void                            ReturnObjectToSlab(slab* source, void* object,
                                                                        uint32 flags);
                        void*                           ObjectAtIndex(slab* source, int32 index) const;

                        bool                            Lock()  { return mutex_lock(&lock) == B_OK; }
                        void                            Unlock()        { mutex_unlock(&lock); }

                        status_t                        AllocatePages(void** pages, uint32 flags);
                        void                            FreePages(void* pages);
                        status_t                        EarlyAllocatePages(void** pages, uint32 flags);
                        void                            EarlyFreePages(void* pages);

#if PARANOID_KERNEL_FREE
                        bool                            AssertObjectNotFreed(void* object);
#endif

                        status_t                        AllocateTrackingInfos(slab* slab,
                                                                        size_t byteCount, uint32 flags);
                        void                            FreeTrackingInfos(slab* slab, uint32 flags);

#if SLAB_OBJECT_CACHE_ALLOCATION_TRACKING
                        AllocationTrackingInfo*
                                                                TrackingInfoFor(void* object) const;
#endif
};


static inline void*
link_to_object(slab_queue_link* link, size_t objectSize)
{
        return ((uint8*)link) - (objectSize - sizeof(slab_queue_link));
}


static inline slab_queue_link*
object_to_link(void* object, size_t objectSize)
{
        return (slab_queue_link*)(((uint8*)object)
                + (objectSize - sizeof(slab_queue_link)));
}


static inline void*
lower_boundary(const void* object, size_t byteCount)
{
        return (void*)((addr_t)object & ~(byteCount - 1));
}


static inline bool
check_cache_quota(ObjectCache* cache)
{
        if (cache->maximum == 0)
                return true;

        return (cache->usage + cache->slab_size) <= cache->maximum;
}


#if !SLAB_OBJECT_CACHE_ALLOCATION_TRACKING

inline status_t
ObjectCache::AllocateTrackingInfos(slab* slab, size_t byteCount, uint32 flags)
{
        return B_OK;
}


inline void
ObjectCache::FreeTrackingInfos(slab* slab, uint32 flags)
{
}

#endif // !SLAB_OBJECT_CACHE_ALLOCATION_TRACKING

#endif  // OBJECT_CACHE_H