public WrappedDevice(ISegmentedDevice device)
{
_device = device;
_segmentSize = device.GetSegmentSize();
if (!Utility.IsPowerOfTwo(_segmentSize))
{
throw new Exception("Invalid segment size");
}
_segmentSizeBits = Utility.GetLogBase2((ulong)_segmentSize);
_segmentSizeMask = _segmentSize - 1;
}
/// <summary>
/// Initialize
/// </summary>
/// <param name="version"></param>
/// <param name="size"></param>
/// <param name="sector_size"></param>
internal void Initialize(int version, long size, int sector_size)
{
long size_bytes = size * sizeof(HashBucket);
long aligned_size_bytes = sector_size +
((size_bytes + (sector_size - 1)) & ~(sector_size - 1));
//Over-allocate and align the table to the cacheline
state[version].size = size;
state[version].size_mask = size - 1;
state[version].size_bits = Utility.GetLogBase2((int)size);
state[version].tableRaw = new HashBucket[aligned_size_bytes / Constants.kCacheLineBytes];
state[version].tableHandle = GCHandle.Alloc(state[version].tableRaw, GCHandleType.Pinned);
long sectorAlignedPointer = ((long)state[version].tableHandle.AddrOfPinnedObject() + (sector_size - 1)) & ~(sector_size - 1);
state[version].tableAligned = (HashBucket *)sectorAlignedPointer;
}
/// <summary>
/// Initialize device
/// </summary>
/// <param name="segmentSize"></param>
public void Initialize(long segmentSize)
{
this.segmentSize = segmentSize;
if (!Utility.IsPowerOfTwo(segmentSize))
{
if (segmentSize != -1)
{
throw new Exception("Invalid segment size: " + segmentSize);
}
segmentSizeBits = 64;
segmentSizeMask = ~0UL;
}
else
{
segmentSizeBits = Utility.GetLogBase2((ulong)segmentSize);
segmentSizeMask = (ulong)segmentSize - 1;
}
}
/// <summary>
/// Initialize device
/// </summary>
/// <param name="segmentSize"></param>
/// <param name="epoch"></param>
public virtual void Initialize(long segmentSize, LightEpoch epoch = null)
{
Debug.Assert(Capacity == -1 || Capacity % segmentSize == 0, "capacity must be a multiple of segment sizes");
this.segmentSize = segmentSize;
this.epoch = epoch;
if (!Utility.IsPowerOfTwo(segmentSize))
{
if (segmentSize != -1)
{
throw new FasterException("Invalid segment size: " + segmentSize);
}
segmentSizeBits = 64;
segmentSizeMask = ~0UL;
}
else
{
segmentSizeBits = Utility.GetLogBase2((ulong)segmentSize);
segmentSizeMask = (ulong)segmentSize - 1;
}
}
/// <summary>
/// Initialize device
/// </summary>
/// <param name="segmentSize"></param>
/// <param name="epoch"></param>
public virtual void Initialize(long segmentSize, LightEpoch epoch = null)
{
// TODO(Tianyu): Alternatively, we can adjust capacity based on the segment size: given a phsyical upper limit of capacity,
// we only make use of (Capacity / segmentSize * segmentSize) many bytes.
Debug.Assert(Capacity == -1 || Capacity % segmentSize == 0, "capacity must be a multiple of segment sizes");
this.segmentSize = segmentSize;
this.epoch = epoch;
if (!Utility.IsPowerOfTwo(segmentSize))
{
if (segmentSize != -1)
{
throw new Exception("Invalid segment size: " + segmentSize);
}
segmentSizeBits = 64;
segmentSizeMask = ~0UL;
}
else
{
segmentSizeBits = Utility.GetLogBase2((ulong)segmentSize);
segmentSizeMask = (ulong)segmentSize - 1;
}
}
public StorageDeviceBase(
string filename, long segmentSize, uint sectorSize)
{
FileName = filename;
SegmentSize = segmentSize;
if (!Utility.IsPowerOfTwo(segmentSize))
{
if (segmentSize != -1)
{
throw new Exception("Invalid segment size: " + segmentSize);
}
segmentSizeBits = 64;
segmentSizeMask = ~0UL;
}
else
{
segmentSizeBits = Utility.GetLogBase2((ulong)segmentSize);
segmentSizeMask = (ulong)segmentSize - 1;
}
SectorSize = sectorSize;
}
