diff --git a/src/add-ons/kernel/file_systems/ramfs/AreaUtils.cpp b/src/add-ons/kernel/file_systems/ramfs/AreaUtils.cpp deleted file mode 100644 index 31838533b9..0000000000 --- a/src/add-ons/kernel/file_systems/ramfs/AreaUtils.cpp +++ /dev/null @@ -1,138 +0,0 @@ -/* - * Copyright 2003, Ingo Weinhold, ingo_weinhold@gmx.de. - * All rights reserved. Distributed under the terms of the MIT license. - */ - -#include - -#include "AreaUtils.h" -#include "DebugSupport.h" -#include "Misc.h" - -#ifndef USE_STANDARD_FUNCTIONS -#define USE_STANDARD_FUNCTIONS 0 -#endif - - -// area_info_for -static -status_t -area_info_for(void *address, area_info *info) -{ - status_t error = B_OK; - if (address) { - // get the area ID for the ptr - area_id area = area_for(address); - // check if supplied pointer points to the beginning of the area - if (area >= 0) - error = get_area_info(area, info); - else - error = area; - } else - error = B_BAD_VALUE; - return error; -} - -// calloc -void * -AreaUtils::calloc(size_t nmemb, size_t size) -{ -//PRINT(("AreaUtils::calloc(%lu, %lu)\n", nmemb, size)); - return AreaUtils::malloc(nmemb * size); -} - -// free -void -AreaUtils::free(void *ptr) -{ -//PRINT(("AreaUtils::free(%p)\n", ptr)); -#if USE_STANDARD_FUNCTIONS - return ::free(ptr); -#else - if (ptr) { - // get the area for the pointer - area_info info; - if (area_info_for(ptr, &info) == B_OK) { - if (ptr == info.address) { - // everything is fine, delete the area - delete_area(info.area); - } else { - INFORM("WARNING: AreaUtils::free(%p): area begin is %p." - "Ignored.\n", ptr, info.address); - } - } - } -#endif -} - -// malloc -void * -AreaUtils::malloc(size_t size) -{ -//PRINT(("AreaUtils::malloc(%lu)\n", size)); -#if USE_STANDARD_FUNCTIONS - return ::malloc(size); -#else - void *address = NULL; - if (size > 0) { - // round to multiple of page size - size = (size + B_PAGE_SIZE - 1) / B_PAGE_SIZE * B_PAGE_SIZE; - // create an area -#if USER - area_id area = create_area("AreaUtils::malloc", &address, - B_ANY_ADDRESS, size, B_NO_LOCK, - B_WRITE_AREA | B_READ_AREA); -#else - area_id area = create_area("AreaUtils::malloc", &address, - B_ANY_KERNEL_ADDRESS, size, B_FULL_LOCK, - B_READ_AREA | B_WRITE_AREA); -#endif - if (area < 0) - address = NULL; - } - return address; -#endif -} - -// realloc -void * -AreaUtils::realloc(void * ptr, size_t size) -{ -//PRINT(("AreaUtils::realloc(%p, %lu)\n", ptr, size)) -#if USE_STANDARD_FUNCTIONS - return ::realloc(ptr, size); -#else - void *newAddress = NULL; - if (size == 0) { - AreaUtils::free(ptr); - } else if (ptr) { - // get the area for the pointer - area_info info; - if (area_info_for(ptr, &info) == B_OK) { - if (ptr == info.address) { - // round to multiple of page size - size = (size + B_PAGE_SIZE - 1) / B_PAGE_SIZE * B_PAGE_SIZE; - if (size == info.size) { - // nothing to do - newAddress = ptr; - } else if (resize_area(info.area, size) == B_OK) { - // resizing the area went fine - newAddress = ptr; - } else { - // resizing the area failed: we need to allocate a new one - newAddress = AreaUtils::malloc(size); - if (newAddress) { - memcpy(newAddress, ptr, min(size, info.size)); - delete_area(info.area); - } - } - } else { - INFORM("WARNING: AreaUtils::realloc(%p): area begin is %p." - "Ignored.\n", ptr, info.address); - } - } - } - return newAddress; -#endif -} - diff --git a/src/add-ons/kernel/file_systems/ramfs/AreaUtils.h b/src/add-ons/kernel/file_systems/ramfs/AreaUtils.h deleted file mode 100644 index 539c8387a7..0000000000 --- a/src/add-ons/kernel/file_systems/ramfs/AreaUtils.h +++ /dev/null @@ -1,17 +0,0 @@ -/* - * Copyright 2003, Ingo Weinhold, ingo_weinhold@gmx.de. - * All rights reserved. Distributed under the terms of the MIT license. - */ -#ifndef AREA_UTILS_H -#define AREA_UTILS_H - -namespace AreaUtils { - - void *calloc(size_t nmemb, size_t size); - void free(void *ptr); - void *malloc(size_t size); - void *realloc(void * ptr, size_t size); - -}; - -#endif // AREA_UTILS_H diff --git a/src/add-ons/kernel/file_systems/ramfs/Jamfile b/src/add-ons/kernel/file_systems/ramfs/Jamfile index 9d14961e76..c5920f53c8 100644 --- a/src/add-ons/kernel/file_systems/ramfs/Jamfile +++ b/src/add-ons/kernel/file_systems/ramfs/Jamfile @@ -8,7 +8,6 @@ DEFINES += DEBUG_APP="\\\"ramfs\\\"" ; KernelAddon ramfs : AllocationInfo.cpp - AreaUtils.cpp Attribute.cpp AttributeIndex.cpp AttributeIndexImpl.cpp diff --git a/src/add-ons/kernel/file_systems/ramfs/NodeChildTable.h b/src/add-ons/kernel/file_systems/ramfs/NodeChildTable.h deleted file mode 100644 index 987ea32b96..0000000000 --- a/src/add-ons/kernel/file_systems/ramfs/NodeChildTable.h +++ /dev/null @@ -1,247 +0,0 @@ -/* - * Copyright 2007, Ingo Weinhold, ingo_weinhold@gmx.de. - * All rights reserved. Distributed under the terms of the MIT license. - */ -#ifndef NODE_CHILD_TABLE_H -#define NODE_CHILD_TABLE_H - -#include "AllocationInfo.h" -#include "DebugSupport.h" -#include "Misc.h" -#include "Node.h" -#include "OpenHashTable.h" - -// NodeChildHashElement -template -class NodeChildHashElement : public OpenHashElement { -private: - typedef NodeChildHashElement Element; -public: - - NodeChildHashElement() : OpenHashElement(), fID(-1), fChild(NULL) - { - fNext = -1; - } - - static inline uint32 HashFor(ino_t id, const char *name) - { - return node_child_hash(id, name); - } - - static inline uint32 HashFor(ParentNode *parent, NodeChild *child) - { - return node_child_hash(parent->GetID(), child->GetName()); - } - - inline uint32 Hash() const - { - return HashFor(fID, fChild->GetName()); - } - - inline bool Equals(ino_t id, const char *name) - { - return (fID == id && !strcmp(fChild->GetName(), name)); - } - - inline bool operator==(const OpenHashElement &_element) const - { - const Element &element = static_cast(_element); - return Equals(element.fID, element.fChild->GetName()); - } - - inline void Adopt(Element &element) - { - fID = element.fID; - fChild = element.fChild; - } - - ino_t fID; - NodeChild *fChild; -}; - -// NodeChildTable -template -class NodeChildTable { -public: - NodeChildTable(); - ~NodeChildTable(); - - status_t InitCheck() const; - - status_t AddNodeChild(ParentNode *node, NodeChild *child); - status_t AddNodeChild(ino_t, NodeChild *child); - status_t RemoveNodeChild(ParentNode *node, NodeChild *child); - status_t RemoveNodeChild(ino_t id, NodeChild *child); - status_t RemoveNodeChild(ino_t id, const char *name); - NodeChild *GetNodeChild(ino_t id, const char *name); - -protected: - typedef NodeChildHashElement Element; - -private: - Element *_FindElement(ino_t id, const char *name) const; - -protected: - OpenHashElementArray fElementArray; - OpenHashTable > fTable; -}; - -// define convenient instantiation types - -// DirectoryEntryTable -class DirectoryEntryTable : public NodeChildTable { -public: - DirectoryEntryTable() {} - ~DirectoryEntryTable() {} - - void GetAllocationInfo(AllocationInfo &info) - { - info.AddDirectoryEntryTableAllocation(fTable.ArraySize(), - fTable.VectorSize(), - sizeof(Element), - fTable.CountElements()); - } -}; - -// NodeAttributeTable -class NodeAttributeTable : public NodeChildTable { -public: - NodeAttributeTable() {} - ~NodeAttributeTable() {} - - void GetAllocationInfo(AllocationInfo &info) - { - info.AddNodeAttributeTableAllocation(fTable.ArraySize(), - fTable.VectorSize(), - sizeof(Element), - fTable.CountElements()); - } -}; - - -// NodeChildTable implementation - -// constructor -template -NodeChildTable::NodeChildTable() - : fElementArray(1000), - fTable(1000, &fElementArray) -{ -} - -// destructor -template -NodeChildTable::~NodeChildTable() -{ -} - -// InitCheck -template -status_t -NodeChildTable::InitCheck() const -{ - RETURN_ERROR(fTable.InitCheck() && fElementArray.InitCheck() - ? B_OK : B_NO_MEMORY); -} - -// AddNodeChild -template -status_t -NodeChildTable::AddNodeChild(ParentNode *node, - NodeChild *child) -{ - status_t error = (node && child ? B_OK : B_BAD_VALUE); - if (error == B_OK) - error = AddNodeChild(node->GetID(), child); - return error; -} - -// AddNodeChild -template -status_t -NodeChildTable::AddNodeChild(ino_t id, - NodeChild *child) -{ - status_t error = (child ? B_OK : B_BAD_VALUE); - if (error == B_OK) { - Element *element = fTable.Add(Element::HashFor(id, child->GetName())); - if (element) { - element->fID = id; - element->fChild = child; - } else - SET_ERROR(error, B_NO_MEMORY); - } - return error; -} - -// RemoveNodeChild -template -status_t -NodeChildTable::RemoveNodeChild(ParentNode *node, - NodeChild *child) -{ - status_t error = (node && child ? B_OK : B_BAD_VALUE); - if (error == B_OK) - error = RemoveNodeChild(node->GetID(), child->GetName()); - return error; -} - -// RemoveNodeChild -template -status_t -NodeChildTable::RemoveNodeChild(ino_t id, - NodeChild *child) -{ - status_t error = (child ? B_OK : B_BAD_VALUE); - if (error == B_OK) - error = RemoveNodeChild(id, child->GetName()); - return error; -} - -// RemoveNodeChild -template -status_t -NodeChildTable::RemoveNodeChild(ino_t id, - const char *name) -{ - status_t error = B_OK; - if (Element *element = _FindElement(id, name)) - fTable.Remove(element); - else - error = B_ERROR; - return error; -} - -// GetNodeChild -template -NodeChild * -NodeChildTable::GetNodeChild(ino_t id, - const char *name) -{ - NodeChild *child = NULL; - if (Element *element = _FindElement(id, name)) - child = element->fChild; - return child; -} - -// _FindElement -template -typename NodeChildTable::Element * -NodeChildTable::_FindElement(ino_t id, - const char *name) const -{ - Element *element = fTable.FindFirst(Element::HashFor(id, name)); - while (element && !element->Equals(id, name)) { - if (element->fNext >= 0) - element = fTable.ElementAt(element->fNext); - else - element = NULL; - } - return element; -} - - -// undefine the PRINT from -//#undef PRINT - -#endif // NODE_CHILD_TABLE_H diff --git a/src/add-ons/kernel/file_systems/ramfs/OpenHashTable.h b/src/add-ons/kernel/file_systems/ramfs/OpenHashTable.h deleted file mode 100644 index df4685e153..0000000000 --- a/src/add-ons/kernel/file_systems/ramfs/OpenHashTable.h +++ /dev/null @@ -1,498 +0,0 @@ -/* -Open Tracker License - -Terms and Conditions - -Copyright (c) 1991-2000, Be Incorporated. All rights reserved. - -Permission is hereby granted, free of charge, to any person obtaining a copy of -this software and associated documentation files (the "Software"), to deal in -the Software without restriction, including without limitation the rights to -use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies -of the Software, and to permit persons to whom the Software is furnished to do -so, subject to the following conditions: - -The above copyright notice and this permission notice applies to all licensees -and shall be included in all copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF TITLE, MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL -BE INCORPORATED BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN -AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF, OR IN CONNECTION -WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. - -Except as contained in this notice, the name of Be Incorporated shall not be -used in advertising or otherwise to promote the sale, use or other dealings in -this Software without prior written authorization from Be Incorporated. - -Tracker(TM), Be(R), BeOS(R), and BeIA(TM) are trademarks or registered trademarks -of Be Incorporated in the United States and other countries. Other brand product -names are registered trademarks or trademarks of their respective holders. -All rights reserved. -*/ - -// bonefish: -// * removed need for exceptions -// * fixed warnings -// * implemented rehashing -// * hash array and element vector use areas for allocations -// TODO: -// * shrinking of element vectors - -// Hash table with open addresssing - -#ifndef __OPEN_HASH_TABLE__ -#define __OPEN_HASH_TABLE__ - -#include -#include - -#include "AreaUtils.h" -#include "Misc.h" - -// don't include -#ifndef ASSERT -# define ASSERT(E) (void)0 -#endif -#define TRESPASS() (void)0 - -//namespace BPrivate { - -template -class ElementVector { - // element vector for OpenHashTable needs to implement this - // interface -public: - Element &At(int32 index); - Element *Add(); - int32 IndexOf(const Element &) const; - void Remove(int32 index); -}; - -class OpenHashElement { -public: - uint32 Hash() const; - bool operator==(const OpenHashElement &) const; - void Adopt(OpenHashElement &); - // low overhead copy, original element is in undefined state - // after call (calls Adopt on BString members, etc.) - int32 fNext; -}; - -const uint32 kPrimes [] = { - 509, 1021, 2039, 4093, 8191, 16381, 32749, 65521, 131071, 262139, - 524287, 1048573, 2097143, 4194301, 8388593, 16777213, 33554393, 67108859, - 134217689, 268435399, 536870909, 1073741789, 2147483647, 0 -}; - -template > -class OpenHashTable { -public: - OpenHashTable(int32 minSize, ElementVec *elementVector = 0, - float maxLoadFactor = 0.8); - // it is up to the subclass of OpenHashTable to supply - // elementVector - ~OpenHashTable(); - - bool InitCheck() const; - - void SetElementVector(ElementVec *elementVector); - - Element *FindFirst(uint32 elementHash) const; - Element *Add(uint32 elementHash); - - void Remove(Element *); - - // when calling Add, any outstanding element pointer may become - // invalid; to deal with this, get the element index and restore - // it after the add - int32 ElementIndex(const Element *) const; - Element *ElementAt(int32 index) const; - - int32 ArraySize() const; - int32 VectorSize() const; - int32 CountElements() const; - -protected: - static int32 OptimalSize(int32 minSize); - -private: - bool _RehashIfNeeded(); - bool _Rehash(); - - int32 fArraySize; - int32 fInitialSize; - int32 fElementCount; - int32 *fHashArray; - ElementVec *fElementVector; - float fMaxLoadFactor; -}; - -template -class OpenHashElementArray : public ElementVector { - // this is a straightforward implementation of an element vector - // deleting is handled by linking deleted elements into a free list - // the vector never shrinks -public: - OpenHashElementArray(int32 initialSize); - ~OpenHashElementArray(); - - bool InitCheck() const; - - Element &At(int32 index); - const Element &At(int32 index) const; - Element *Add(const Element &); - Element *Add(); - void Remove(int32 index); - int32 IndexOf(const Element &) const; - int32 Size() const; - -private: - Element *fData; - int32 fSize; - int32 fNextFree; - int32 fNextDeleted; -}; - - -//----------------------------------- - -template -OpenHashTable::OpenHashTable(int32 minSize, - ElementVec *elementVector, float maxLoadFactor) - : fArraySize(OptimalSize(minSize)), - fInitialSize(fArraySize), - fElementCount(0), - fElementVector(elementVector), - fMaxLoadFactor(maxLoadFactor) -{ - // sanity check the maximal load factor - if (fMaxLoadFactor < 0.5) - fMaxLoadFactor = 0.5; - // allocate and init the array - fHashArray = (int32*)AreaUtils::calloc(fArraySize, sizeof(int32)); - if (fHashArray) { - for (int32 index = 0; index < fArraySize; index++) - fHashArray[index] = -1; - } -} - -template -OpenHashTable::~OpenHashTable() -{ - AreaUtils::free(fHashArray); -} - -template -bool -OpenHashTable::InitCheck() const -{ - return (fHashArray && fElementVector); -} - -template -int32 -OpenHashTable::OptimalSize(int32 minSize) -{ - for (int32 index = 0; ; index++) - if (!kPrimes[index] || kPrimes[index] >= (uint32)minSize) - return (int32)kPrimes[index]; - - return 0; -} - -template -Element * -OpenHashTable::FindFirst(uint32 hash) const -{ - ASSERT(fElementVector); - hash %= fArraySize; - if (fHashArray[hash] < 0) - return 0; - - return &fElementVector->At(fHashArray[hash]); -} - -template -int32 -OpenHashTable::ElementIndex(const Element *element) const -{ - return fElementVector->IndexOf(*element); -} - -template -Element * -OpenHashTable::ElementAt(int32 index) const -{ - return &fElementVector->At(index); -} - -template -int32 -OpenHashTable::ArraySize() const -{ - return fArraySize; -} - -template -int32 -OpenHashTable::VectorSize() const -{ - return fElementVector->Size(); -} - -template -int32 -OpenHashTable::CountElements() const -{ - return fElementCount; -} - - -template -Element * -OpenHashTable::Add(uint32 hash) -{ - ASSERT(fElementVector); - _RehashIfNeeded(); - hash %= fArraySize; - Element *result = fElementVector->Add(); - if (result) { - result->fNext = fHashArray[hash]; - fHashArray[hash] = fElementVector->IndexOf(*result); - fElementCount++; - } - return result; -} - -template -void -OpenHashTable::Remove(Element *element) -{ - _RehashIfNeeded(); - uint32 hash = element->Hash() % fArraySize; - int32 next = fHashArray[hash]; - ASSERT(next >= 0); - - if (&fElementVector->At(next) == element) { - fHashArray[hash] = element->fNext; - fElementVector->Remove(next); - fElementCount--; - return; - } - - for (int32 index = next; index >= 0; ) { - // look for an existing match in table - next = fElementVector->At(index).fNext; - if (next < 0) { - TRESPASS(); - return; - } - - if (&fElementVector->At(next) == element) { - fElementVector->At(index).fNext = element->fNext; - fElementVector->Remove(next); - fElementCount--; - return; - } - index = next; - } -} - -template -void -OpenHashTable::SetElementVector(ElementVec *elementVector) -{ - fElementVector = elementVector; -} - -// _RehashIfNeeded -template -bool -OpenHashTable::_RehashIfNeeded() -{ - // The load factor range [fMaxLoadFactor / 3, fMaxLoadFactor] is fine, - // I think. After rehashing the load factor will be about - // fMaxLoadFactor * 2 / 3, respectively fMaxLoadFactor / 2. - float loadFactor = (float)fElementCount / (float)fArraySize; - if (loadFactor > fMaxLoadFactor - || (fArraySize > fInitialSize && loadFactor < fMaxLoadFactor / 3)) { - return _Rehash(); - } - return true; -} - -// _Rehash -template -bool -OpenHashTable::_Rehash() -{ - bool result = true; - int32 newSize = max(fInitialSize, - int32(fElementCount * 1.73 * fMaxLoadFactor)); - newSize = OptimalSize(newSize); - if (newSize != fArraySize) { -PRINT(("_Rehash(): %lu -> %lu (currently %lu entries)\n", fArraySize, newSize, -fElementCount)); - // allocate a new array - int32 *newHashArray - = (int32*)AreaUtils::calloc(newSize, sizeof(int32)); - if (newHashArray) { - // init the new hash array - for (int32 index = 0; index < newSize; index++) - newHashArray[index] = -1; - // iterate through all elements and put them into the new - // hash array - for (int i = 0; i < fArraySize; i++) { - int32 index = fHashArray[i]; - while (index >= 0) { - // insert the element in the new array - Element &element = fElementVector->At(index); - int32 next = element.fNext; - uint32 hash = (element.Hash() % newSize); - element.fNext = newHashArray[hash]; - newHashArray[hash] = index; - // next element in old list - index = next; - } - } - // delete the old array and set the new one - AreaUtils::free(fHashArray); - fHashArray = newHashArray; - fArraySize = newSize; - } else - result = false; - } - return result; -} - - -template -OpenHashElementArray::OpenHashElementArray(int32 initialSize) - : fSize(initialSize), - fNextFree(0), - fNextDeleted(-1) -{ - fData = (Element*)AreaUtils::calloc((size_t)initialSize, sizeof(Element)); -} - -template -OpenHashElementArray::~OpenHashElementArray() -{ - AreaUtils::free(fData); -} - -template -bool -OpenHashElementArray::InitCheck() const -{ - return fData; -} - -template -Element & -OpenHashElementArray::At(int32 index) -{ - ASSERT(index < fSize); - return fData[index]; -} - -template -const Element & -OpenHashElementArray::At(int32 index) const -{ - ASSERT(index < fSize); - return fData[index]; -} - -template -int32 -OpenHashElementArray::IndexOf(const Element &element) const -{ - int32 result = &element - fData; - if (result < 0 || result > fSize) - return -1; - - return result; -} - -template -int32 -OpenHashElementArray::Size() const -{ - return fSize; -} - - -template -Element * -OpenHashElementArray::Add(const Element &newElement) -{ - Element *element = Add(); - if (element) - element.Adopt(newElement); - return element; -} - -#if DEBUG -const int32 kGrowChunk = 10; -#else -const int32 kGrowChunk = 1024; -#endif - -template -Element * -OpenHashElementArray::Add() -{ - int32 index = fNextFree; - if (fNextDeleted >= 0) { - index = fNextDeleted; - fNextDeleted = At(index).fNext; - } else if (fNextFree >= fSize - 1) { - int32 newSize = fSize + kGrowChunk; -/* - Element *newData = (Element *)calloc((size_t)newSize , sizeof(Element)); - if (!newData) - return NULL; - memcpy(newData, fData, fSize * sizeof(Element)); - free(fData); -*/ - Element *newData = (Element*)AreaUtils::realloc(fData, - (size_t)newSize * sizeof(Element)); - if (!newData) - return NULL; - - fData = newData; - fSize = newSize; - index = fNextFree; - fNextFree++; - } else - fNextFree++; - - new (&At(index)) Element; - // call placement new to initialize the element properly - ASSERT(At(index).fNext == -1); - - return &At(index); -} - -template -void -OpenHashElementArray::Remove(int32 index) -{ - // delete by chaining empty elements in a single linked - // list, reusing the next field - ASSERT(index < fSize); - At(index).~Element(); - // call the destructor explicitly to destroy the element - // properly - At(index).fNext = fNextDeleted; - fNextDeleted = index; -} - -//} // namespace BPrivate - -//using namespace BPrivate; - -#endif