public double calculateAvgFreeForDie(int blockNo, int dieCntr)
{
ulong sumOfFree = 0;
for (int planeCntr = 0; planeCntr < PlaneNoPerDie; planeCntr++)
{
FlashChipBlock targetBlock = Dies[dieCntr].Planes[planeCntr].Blocks[blockNo];
sumOfFree += targetBlock.FreePageNo;
}
return(((double)sumOfFree) / ((double)(PlaneNoPerDie)));
}
public double calculateAvgValidForDie(int blockNo, int dieCntr)
{
ulong sumOfValid = 0;
for (int planeCntr = 0; planeCntr < PlaneNoPerDie; planeCntr++)
{
FlashChipBlock targetBlock = Dies[dieCntr].Planes[planeCntr].Blocks[blockNo];
sumOfValid += PageNoPerBlock - targetBlock.InvalidPageNo - targetBlock.FreePageNo;
}
return(((double)sumOfValid) / ((double)(PlaneNoPerDie)));
}
public double calculateVariaceinValidForDie(int blockNo, int dieCntr)
{
double average = calculateAvgInvalidForDie(blockNo, dieCntr);
ulong sumOfSquare = 0;
for (int planeCntr = 0; planeCntr < PlaneNoPerDie; planeCntr++)
{
FlashChipBlock targetBlock = Dies[dieCntr].Planes[planeCntr].Blocks[blockNo];
sumOfSquare += targetBlock.InvalidPageNo * targetBlock.InvalidPageNo;
}
return((double)sumOfSquare / ((double)(PlaneNoPerDie)) - average * average);
}
public double calculateAverageFreeForFlashChip(int blockNo)
{
ulong sumOfFree = 0;
for (int dieCntr = 0; dieCntr < Dies.Length; dieCntr++)
{
for (int planeCntr = 0; planeCntr < PlaneNoPerDie; planeCntr++)
{
FlashChipBlock targetBlock = Dies[dieCntr].Planes[planeCntr].Blocks[blockNo];
sumOfFree += targetBlock.FreePageNo;
}
}
return(((double)sumOfFree) / ((double)(Dies.Length * PlaneNoPerDie)));
}
public double calculateVariaceFreeForFlashChip(int blockNo)
{
double average = calculateAverageFreeForFlashChip(blockNo);
ulong sumOfSquare = 0;
for (int dieCntr = 0; dieCntr < Dies.Length; dieCntr++)
{
for (int planeCntr = 0; planeCntr < PlaneNoPerDie; planeCntr++)
{
FlashChipBlock targetBlock = Dies[dieCntr].Planes[planeCntr].Blocks[blockNo];
sumOfSquare += targetBlock.FreePageNo * targetBlock.FreePageNo;
}
}
return((double)sumOfSquare / ((double)(Dies.Length * PlaneNoPerDie)) - average * average);
}
public FlashChipPlane(uint channelID, uint overallChipID, uint localChipID, uint dieID, uint planeID,
uint BlocksNoPerPlane, uint PagesNoPerBlock)
{
this.PlaneGlobalAddress = new IntegerPageAddress(channelID, localChipID, dieID, planeID, 0, 0, overallChipID);
this.BlockNo = BlocksNoPerPlane;
this.FreePagesNo = BlocksNoPerPlane * PagesNoPerBlock;
this.Blocks = new FlashChipBlock[BlocksNoPerPlane];
for (uint i = 0; i < BlocksNoPerPlane; i++)
{
this.Blocks[i] = new FlashChipBlock(PagesNoPerBlock, i);
}
this.ReadCount = 0;
this.ProgamCount = 0;
this.EraseCount = 0;
this.CurrentActiveBlockID = 0;
this.CurrentActiveBlock = this.Blocks[0];
}
public override void ProcessXEvent(XEvent e)
{
if (e.Removed)
{
return;
}
//Just only one xevent: OperationFinished
InternalRequest targetRequest = e.Parameters as InternalRequest;
FlashChipDie targetDie = this.Dies[targetRequest.TargetPageAddress.DieID];
targetDie.CurrentExecutingOperationCount--;
if (targetDie.CurrentExecutingOperationCount == 0)
{
targetDie.Status = DieStatus.Idle;
}
targetDie.Planes[targetRequest.TargetPageAddress.PlaneID].Status = PlaneStatus.Idle;
targetDie.Planes[targetRequest.TargetPageAddress.PlaneID].CurrentExecutingRequest = null;
CurrentExecutingOperationCount--;
if (CurrentExecutingOperationCount == 0)
{
Status = FlashChipStatus.Idle;
totalCommandExecutionPeriod += XEngineFactory.XEngine.Time - ThisRoundExecutionStart;
ThisRoundExecutionFinish = XEngineFactory.XEngine.Time;
}
switch (targetRequest.Type)
{
case InternalRequestType.Read:
this.ReadCount++;
targetDie.Planes[targetRequest.TargetPageAddress.PlaneID].ReadCount++;
targetRequest.ExecutionTime += this.readLatency;
this.Status = FlashChipStatus.Waiting;
//Either a normal read (waiting for read data transfer) or a copyback read (waiting for write execution)
this.CurrentWaitingTransfers++;
if (targetDie.Status == DieStatus.Idle)
{
targetDie.TotalReadExecutionPeriod += readLatency;
}
break;
case InternalRequestType.Write:
this.ProgamCount++;
targetDie.Planes[targetRequest.TargetPageAddress.PlaneID].ProgamCount++;
targetRequest.ExecutionTime += this.programLatency;
if (targetDie.Status == DieStatus.Idle)
{
targetDie.TotalProgramExecutionPeriod += programLatency;
}
break;
case InternalRequestType.Clean:
this.EraseCount++;
targetDie.Planes[targetRequest.TargetPageAddress.PlaneID].EraseCount++;
targetRequest.ExecutionTime += this.eraseLatency;
FlashChipBlock targetBlock = this.Dies[targetRequest.TargetPageAddress.DieID].Planes[targetRequest.TargetPageAddress.PlaneID].Blocks[targetRequest.TargetPageAddress.BlockID];
targetDie.Planes[targetRequest.TargetPageAddress.PlaneID].FreePagesNo += (PageNoPerBlock - targetBlock.FreePageNo);
targetBlock.FreePageNo = PageNoPerBlock;
targetBlock.InvalidPageNo = 0;
targetBlock.LastWrittenPageNo = -1;
targetBlock.EraseCount++;
for (int i = 0; i < PageNoPerBlock; i++)
{
targetBlock.Pages[i].StreamID = FlashChipPage.PG_NOSTREAM;
targetBlock.Pages[i].ValidStatus = FlashChipPage.PG_FREE;
targetBlock.Pages[i].LPN = ulong.MaxValue;
}
#region UpdateFastGCData
targetDie.BlockInfoAbstract[targetBlock.BlockID].FreePageNo += PageNoPerBlock;
targetDie.BlockInfoAbstract[targetBlock.BlockID].InvalidPageNo = 0;
targetDie.BlockInfoAbstract[targetBlock.BlockID].EraseCount++;
#endregion
if (targetDie.Status == DieStatus.Idle)
{
targetDie.TotalEraseExecutionPeriod += eraseLatency;
}
break;
default:
break;
}
OnInternalRequestServiced(targetRequest);
}
public override void Snapshot(string id, System.Xml.XmlTextWriter writer)
{
writer.WriteStartElement(id);
writer.WriteAttributeString("ID", ID.ToString());
writer.WriteAttributeString("ReadCount", ReadCount.ToString());
writer.WriteAttributeString("ProgamCount", ProgamCount.ToString());
writer.WriteAttributeString("EraseCount", EraseCount.ToString());
writer.WriteAttributeString("TotalExecutionPeriodRatio", ((double)totalCommandExecutionPeriod / (double)XEngineFactory.XEngine.Time).ToString());
writer.WriteAttributeString("TotalTransferPeriodRatio", ((double)TotalTransferPeriod / (double)XEngineFactory.XEngine.Time).ToString());
writer.WriteAttributeString("TotalTransferPeriodOverlapped", ((double)TotalTransferPeriodOverlapped / (double)XEngineFactory.XEngine.Time).ToString());
for (int dieCntr = 0; dieCntr < Dies.Length; dieCntr++)
{
writer.WriteStartElement(id + "_Die");
writer.WriteAttributeString("ID", ID.ToString() + ".die." + dieCntr);
writer.WriteAttributeString("TotalReadExecutionPeriodRatio", ((double)Dies[dieCntr].TotalReadExecutionPeriod / (double)XEngineFactory.XEngine.Time).ToString());
writer.WriteAttributeString("TotalProgramExecutionPeriodRatio", ((double)Dies[dieCntr].TotalProgramExecutionPeriod / (double)XEngineFactory.XEngine.Time).ToString());
writer.WriteAttributeString("TotalEraseExecutionPeriodRatio", ((double)Dies[dieCntr].TotalEraseExecutionPeriod / (double)XEngineFactory.XEngine.Time).ToString());
writer.WriteAttributeString("TotalTransferPeriodRatio", ((double)Dies[dieCntr].TotalTransferPeriod / (double)XEngineFactory.XEngine.Time).ToString());
for (int planeCntr = 0; planeCntr < PlaneNoPerDie; planeCntr++)
{
writer.WriteStartElement(id + "_Plane");
writer.WriteAttributeString("ID", ID.ToString() + ".plane." + dieCntr + "." + planeCntr);
uint freePagesNo = 0, totalPagesNo = 0;
uint totalBlockEraseCount = 0, maxBlockErasureCount = 0, minBlockErasureCount = uint.MaxValue;
uint totalValidPagesCount = 0, maxBlockValidPagesCount = 0, minBlockValidPagesCount = uint.MaxValue;
uint totalInvalidPagesCount = 0, maxBlockInvalidPagesCount = 0, minBlockInvalidPagesCount = uint.MaxValue;
double averageBlockEraseCount = 0, blockEraseStdDev = 0;
double averageBlockValidPagesCount, blockValidPagesCountStdDev = 0, averageBlockInvalidPagesCount, blockInvalidPagesCountStdDev = 0;
for (int blockCntr = 0; blockCntr < BlockNoPerPlane; blockCntr++)
{
FlashChipBlock targetBlock = Dies[dieCntr].Planes[planeCntr].Blocks[blockCntr];
totalBlockEraseCount += targetBlock.EraseCount;
if (targetBlock.EraseCount > maxBlockErasureCount)
{
maxBlockErasureCount = targetBlock.EraseCount;
}
if (targetBlock.EraseCount < minBlockErasureCount)
{
minBlockErasureCount = targetBlock.EraseCount;
}
uint validpagecount = PageNoPerBlock - targetBlock.InvalidPageNo - targetBlock.FreePageNo;
totalValidPagesCount += validpagecount;
if (validpagecount > maxBlockValidPagesCount)
{
maxBlockValidPagesCount = validpagecount;
}
if (validpagecount < minBlockValidPagesCount)
{
minBlockValidPagesCount = validpagecount;
}
totalPagesNo += (uint)Dies[dieCntr].Planes[planeCntr].Blocks[blockCntr].Pages.Length;
totalInvalidPagesCount += targetBlock.InvalidPageNo;
if (targetBlock.InvalidPageNo > maxBlockInvalidPagesCount)
{
maxBlockInvalidPagesCount = targetBlock.InvalidPageNo;
}
if (targetBlock.InvalidPageNo < minBlockInvalidPagesCount)
{
minBlockInvalidPagesCount = targetBlock.InvalidPageNo;
}
freePagesNo += targetBlock.FreePageNo;
}
averageBlockEraseCount = (double)totalBlockEraseCount / (double)(BlockNoPerPlane);
averageBlockValidPagesCount = (double)totalValidPagesCount / (double)(BlockNoPerPlane);
averageBlockInvalidPagesCount = (double)totalInvalidPagesCount / (double)(BlockNoPerPlane);
for (uint blockCntr = 0; blockCntr < BlockNoPerPlane; blockCntr++)
{
FlashChipBlock targetBlock = Dies[dieCntr].Planes[planeCntr].Blocks[blockCntr];
uint validPagesCount = PageNoPerBlock - targetBlock.InvalidPageNo - targetBlock.FreePageNo;
blockEraseStdDev += Math.Pow((averageBlockEraseCount - targetBlock.EraseCount), 2);
blockValidPagesCountStdDev += Math.Pow((averageBlockValidPagesCount - validPagesCount), 2);
blockInvalidPagesCountStdDev += Math.Pow((averageBlockInvalidPagesCount - targetBlock.InvalidPageNo), 2);
}
blockEraseStdDev = Math.Sqrt((double)blockEraseStdDev / (double)BlockNoPerPlane);
blockValidPagesCountStdDev = Math.Sqrt((double)blockValidPagesCountStdDev / (double)BlockNoPerPlane);
blockInvalidPagesCountStdDev = Math.Sqrt((double)blockInvalidPagesCountStdDev / (double)BlockNoPerPlane);
writer.WriteAttributeString("ReadCount", Dies[dieCntr].Planes[planeCntr].ReadCount.ToString());
writer.WriteAttributeString("ProgramCount", Dies[dieCntr].Planes[planeCntr].ProgamCount.ToString());
writer.WriteAttributeString("EraseCount", Dies[dieCntr].Planes[planeCntr].EraseCount.ToString());
writer.WriteAttributeString("TotalPagesNo", totalPagesNo.ToString());
writer.WriteAttributeString("ValidPagesNo", totalValidPagesCount.ToString());
writer.WriteAttributeString("FreePagesNo", freePagesNo.ToString());
writer.WriteAttributeString("InvalidPagesNo", totalInvalidPagesCount.ToString());
writer.WriteAttributeString("BlockEraseCountAverage", averageBlockEraseCount.ToString());
writer.WriteAttributeString("BlockEraseCountStdDev", blockEraseStdDev.ToString());
writer.WriteAttributeString("BlockEraseCountMin", minBlockErasureCount.ToString());
writer.WriteAttributeString("BlockEraseCountMax", maxBlockErasureCount.ToString());
writer.WriteAttributeString("BlockValidPagesCountAverage", averageBlockValidPagesCount.ToString());
writer.WriteAttributeString("BlockValidPagesCountStdDev", blockValidPagesCountStdDev.ToString());
writer.WriteAttributeString("BlockValidPagesCountMin", minBlockValidPagesCount.ToString());
writer.WriteAttributeString("BlockValidPagesCountMax", maxBlockValidPagesCount.ToString());
writer.WriteAttributeString("BlockInvalidPagesCountAverage", averageBlockInvalidPagesCount.ToString());
writer.WriteAttributeString("BlockInvalidPagesCountStdDev", blockInvalidPagesCountStdDev.ToString());
writer.WriteAttributeString("BlockInvalidPagesCountMin", minBlockInvalidPagesCount.ToString());
writer.WriteAttributeString("BlockInvalidPagesCountMax", maxBlockInvalidPagesCount.ToString());
writer.WriteEndElement();
}
writer.WriteEndElement(); //Die
}
writer.WriteEndElement(); //Flashchip
}
