haiku.git

/*
 * Copyright 2013-2014, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */
#ifndef HEAP_CACHE_H
#define HEAP_CACHE_H


#include <package/hpkg/DataReader.h>

#include <condition_variable.h>
#include <util/DoublyLinkedList.h>
#include <util/OpenHashTable.h>
#include <vm/vm_types.h>


using BPackageKit::BHPKG::BAbstractBufferedDataReader;
using BPackageKit::BHPKG::BDataReader;


class CachedDataReader : public BAbstractBufferedDataReader {
public:
								CachedDataReader();
	virtual						~CachedDataReader();

			status_t			Init(BAbstractBufferedDataReader* reader,
									off_t size);

	virtual	status_t			ReadDataToOutput(off_t offset, size_t size,
									BDataIO* output);

private:
			class CacheLineLocker
				: public DoublyLinkedListLinkImpl<CacheLineLocker> {
			public:
				CacheLineLocker(CachedDataReader* reader, off_t cacheLineOffset)
					:
					fReader(reader),
					fOffset(cacheLineOffset)
				{
					fReader->_LockCacheLine(this);
				}

				~CacheLineLocker()
				{
					fReader->_UnlockCacheLine(this);
				}

				off_t Offset() const
				{
					return fOffset;
				}

				CacheLineLocker*& HashNext()
				{
					return fHashNext;
				}

				DoublyLinkedList<CacheLineLocker>& Queue()
				{
					return fQueue;
				}

				void Wait(mutex& lock)
				{
					fWaitCondition.Init(this, "cached reader line locker");
					ConditionVariableEntry waitEntry;
					fWaitCondition.Add(&waitEntry);
					mutex_unlock(&lock);
					waitEntry.Wait();
					mutex_lock(&lock);
				}

				void WakeUp()
				{
					fWaitCondition.NotifyOne();
				}

			private:
				CachedDataReader*					fReader;
				off_t								fOffset;
				CacheLineLocker*					fHashNext;
				DoublyLinkedList<CacheLineLocker>	fQueue;
				ConditionVariable					fWaitCondition;
			};

			friend class CacheLineLocker;

			struct LockerHashDefinition {
				typedef off_t			KeyType;
				typedef	CacheLineLocker	ValueType;

				size_t HashKey(off_t key) const
				{
					return size_t(key / kCacheLineSize);
				}

				size_t Hash(const CacheLineLocker* value) const
				{
					return HashKey(value->Offset());
				}

				bool Compare(off_t key, const CacheLineLocker* value) const
				{
					return value->Offset() == key;
				}

				CacheLineLocker*& GetLink(CacheLineLocker* value) const
				{
					return value->HashNext();
				}
			};

			typedef BOpenHashTable<LockerHashDefinition> LockerTable;

			struct PagesDataOutput;

private:
			status_t			_ReadCacheLine(off_t lineOffset,
									size_t lineSize, off_t requestOffset,
							 		size_t requestLength, BDataIO* output);

			void				_DiscardPages(vm_page** pages, size_t firstPage,
									size_t pageCount);
			void				_CachePages(vm_page** pages, size_t firstPage,
									size_t pageCount);
			status_t			_WritePages(vm_page** pages,
									size_t pagesRelativeOffset,
									size_t requestLength, BDataIO* output);
			status_t			_ReadIntoPages(vm_page** pages,
									size_t firstPage, size_t pageCount);

			void				_LockCacheLine(CacheLineLocker* lineLocker);
			void				_UnlockCacheLine(CacheLineLocker* lineLocker);

private:
			static const size_t kCacheLineSize = 64 * 1024;
			static const size_t kPagesPerCacheLine
				= kCacheLineSize / B_PAGE_SIZE;

private:
			mutex				fLock;
			BAbstractBufferedDataReader* fReader;
			VMCache*			fCache;
			LockerTable			fCacheLineLockers;
};


#endif	// HEAP_CACHE_H