95 lines
3.0 KiB
C++
95 lines
3.0 KiB
C++
/*
|
|
* Copyright (C) 2021-2025 Intel Corporation
|
|
*
|
|
* SPDX-License-Identifier: MIT
|
|
*
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include "shared/source/helpers/common_types.h"
|
|
#include "shared/source/helpers/non_copyable_or_moveable.h"
|
|
#include "shared/source/os_interface/linux/clos_cache.h"
|
|
#include "shared/source/utilities/spinlock.h"
|
|
|
|
#include <array>
|
|
#include <cstddef>
|
|
#include <cstdint>
|
|
|
|
namespace NEO {
|
|
|
|
class IoctlHelper;
|
|
|
|
struct CacheReservationParameters {
|
|
size_t maxSize{0U};
|
|
uint32_t maxNumRegions{0U};
|
|
uint16_t maxNumWays{0U};
|
|
};
|
|
|
|
struct CacheInfo : NEO::NonCopyableAndNonMovableClass {
|
|
CacheInfo(IoctlHelper &ioctlHelper, const CacheReservationParameters l2Limits, const CacheReservationParameters l3Limits)
|
|
: l2ReservationLimits{l2Limits},
|
|
l3ReservationLimits{l3Limits},
|
|
cacheReserve{ioctlHelper} {
|
|
|
|
reservedCacheRegionsSize.fill(0UL);
|
|
}
|
|
|
|
MOCKABLE_VIRTUAL ~CacheInfo();
|
|
|
|
size_t getMaxReservationCacheSize(CacheLevel cacheLevel) const {
|
|
return getLimitsForCacheLevel(cacheLevel).maxSize;
|
|
}
|
|
|
|
size_t getMaxReservationNumCacheRegions(CacheLevel cacheLevel) const {
|
|
return getLimitsForCacheLevel(cacheLevel).maxNumRegions;
|
|
}
|
|
|
|
size_t getMaxReservationNumWays(CacheLevel cacheLevel) const {
|
|
return getLimitsForCacheLevel(cacheLevel).maxNumWays;
|
|
}
|
|
|
|
CacheRegion reserveCacheRegion(CacheLevel cacheLevel, size_t cacheReservationSize) {
|
|
std::unique_lock<SpinLock> lock{mtx};
|
|
return reserveRegion(cacheLevel, cacheReservationSize);
|
|
}
|
|
|
|
CacheRegion freeCacheRegion(CacheLevel cacheLevel, CacheRegion regionIndex) {
|
|
std::unique_lock<SpinLock> lock{mtx};
|
|
return freeRegion(cacheLevel, regionIndex);
|
|
}
|
|
|
|
MOCKABLE_VIRTUAL bool getCacheRegion(size_t regionSize, CacheRegion regionIndex) {
|
|
std::unique_lock<SpinLock> lock{mtx};
|
|
return getRegion(regionSize, regionIndex);
|
|
}
|
|
|
|
CacheLevel getLevelForRegion(CacheRegion regionIndex) const {
|
|
DEBUG_BREAK_IF(regionIndex == CacheRegion::defaultRegion);
|
|
DEBUG_BREAK_IF(regionIndex >= CacheRegion::count);
|
|
return (regionIndex == CacheRegion::region3 ? CacheLevel::level2 : CacheLevel::level3);
|
|
}
|
|
|
|
CacheLevel getLevelForRegion(uint16_t regionIndex) const {
|
|
return getLevelForRegion(toCacheRegion(regionIndex));
|
|
}
|
|
|
|
protected:
|
|
CacheRegion reserveRegion(CacheLevel cacheLevel, size_t cacheReservationSize);
|
|
CacheRegion freeRegion(CacheLevel cacheLevel, CacheRegion regionIndex);
|
|
bool isRegionReserved(CacheRegion regionIndex, [[maybe_unused]] size_t regionSize) const;
|
|
bool getRegion(size_t regionSize, CacheRegion regionIndex);
|
|
const CacheReservationParameters &getLimitsForCacheLevel(CacheLevel cacheLevel) const;
|
|
|
|
protected:
|
|
CacheReservationParameters l2ReservationLimits{};
|
|
CacheReservationParameters l3ReservationLimits{};
|
|
ClosCacheReservation cacheReserve;
|
|
std::array<size_t, toUnderlying(CacheRegion::count)> reservedCacheRegionsSize;
|
|
SpinLock mtx;
|
|
};
|
|
|
|
static_assert(NEO::NonCopyableAndNonMovable<CacheInfo>);
|
|
|
|
} // namespace NEO
|