Fixing a lot of commit warnings and errors

Author: MatiasBjorling

.cproject

@@ -31,7 +31,7 @@
 				</dictionary>
 				<dictionary>
 					<key>org.eclipse.cdt.make.core.buildLocation</key>
-					<value>${workspace_loc:/FTL/Page}</value>
+					<value>${workspace_loc:/FTL/Trace}</value>
 				</dictionary>
 				<dictionary>
 					<key>org.eclipse.cdt.make.core.cleanBuildTarget</key>

.project

@@ -75,20 +75,19 @@ FtlImpl_Bast::FtlImpl_Bast(Controller &controller):
 {
 
 	// Detect required number of bits for logical address size
-	addressSize = log(SSD_SIZE * PACKAGE_SIZE * DIE_SIZE * PLANE_SIZE)/log(2);
+	addressSize = log(NUMBER_OF_ADDRESSABLE_BLOCKS)/log(2);
 	addressShift = log(BLOCK_SIZE)/log(2);
 
 	// Find required number of bits for block size
 	printf("Total required bits for representation: %i (Address: %i Block: %i) \n", addressSize + addressShift, addressSize, addressShift);
 
 	// Initialise block mapping table.
-	uint numBlocks = SSD_SIZE * PACKAGE_SIZE * DIE_SIZE * PLANE_SIZE;
-	data_list = new long[numBlocks];
+	data_list = new long[NUMBER_OF_ADDRESSABLE_BLOCKS];
 
-	for (uint i=0;i<numBlocks;i++)
+	for (uint i=0;i<NUMBER_OF_ADDRESSABLE_BLOCKS;i++)
 		data_list[i] = -1;
 
-	printf("Total mapping table size: %luKB\n", numBlocks * sizeof(uint) / 1024);
+	printf("Total mapping table size: %luKB\n", NUMBER_OF_ADDRESSABLE_BLOCKS * sizeof(uint) / 1024);
 	printf("Using BAST FTL.\n");
 }
 
@@ -287,7 +286,7 @@ bool FtlImpl_Bast::is_sequential(LogPageBlock* logBlock, long lba, Event &event)
 
 	// Is block switch possible? i.e. log block switch
 	bool isSequential = true;
-	for (uint i=0;i<BLOCK_SIZE;i++) if (logBlock->pages[i] != i)
+	for (uint i=0;i<BLOCK_SIZE;i++) if (logBlock->pages[i] != (int)i)
 	{
 		isSequential = false;
 		break;
@@ -329,8 +328,6 @@ bool FtlImpl_Bast::random_merge(LogPageBlock *logBlock, long lba, Event &event)
 	Address eventAddress = Address(event.get_logical_address(), PAGE);
 	Address newDataBlock = Block_manager::instance()->get_free_block(DATA, event);
 
-	Block *b1 = controller.get_block_pointer(logBlock->address);
-
 	int t=0;
 	for (uint i=0;i<BLOCK_SIZE;i++)
 	{
@@ -378,7 +375,6 @@ bool FtlImpl_Bast::random_merge(LogPageBlock *logBlock, long lba, Event &event)
 	if (data_list[lba] != -1)
 	{
 		Address a = Address(data_list[lba], PAGE);
-		Block *b2 = controller.get_block_pointer(a);
 		Block_manager::instance()->erase_and_invalidate(event, a, DATA);
 	}
 

FTLs/bast_ftl.cpp

@@ -49,9 +49,8 @@ FtlImpl_BDftl::BPage::BPage()
 FtlImpl_BDftl::FtlImpl_BDftl(Controller &controller):
 	FtlImpl_DftlParent(controller)
 {
-	uint ssdBlockSize = SSD_SIZE * PACKAGE_SIZE * DIE_SIZE * PLANE_SIZE;
-	block_map = new BPage[ssdBlockSize];
-	trim_map = new bool[ssdBlockSize*BLOCK_SIZE];
+	block_map = new BPage[NUMBER_OF_ADDRESSABLE_BLOCKS];
+	trim_map = new bool[NUMBER_OF_ADDRESSABLE_BLOCKS*BLOCK_SIZE];
 
 	inuseBlock = NULL;
 
@@ -77,7 +76,7 @@ enum status FtlImpl_BDftl::read(Event &event)
 	{
 		uint dppn = block_map[dlbn].pbn + (dlpn % BLOCK_SIZE);
 
-		if (block_map[dlbn].pbn != -1)
+		if (block_map[dlbn].pbn != (uint) -1)
 			event.set_address(Address(dppn, PAGE));
 		else
 		{
@@ -349,7 +348,6 @@ void FtlImpl_BDftl::cleanup_block(Event &event, Block *block)
 	 * 2. Invalidate old pages
 	 * 3. mark their corresponding translation pages for update
 	 */
-	uint cnt=0;
 	for (uint i=0;i<BLOCK_SIZE;i++)
 	{
 		assert(block->get_state(i) != EMPTY);
@@ -368,9 +366,7 @@ void FtlImpl_BDftl::cleanup_block(Event &event, Block *block)
 			// Get new address to write to and invalidate previous
 			Event writeEvent = Event(WRITE, event.get_logical_address(), 1, event.get_start_time()+readEvent.get_time_taken());
 			Address dataBlockAddress = Address(get_free_data_page(event, false), PAGE);
-			Block *entryBlock = controller.get_block_pointer(dataBlockAddress);
 			writeEvent.set_address(dataBlockAddress);
-
 			writeEvent.set_replace_address(Address(block->get_physical_address()+i, PAGE));
 
 			// Setup the write event to read from the right place.
@@ -438,13 +434,11 @@ bool FtlImpl_BDftl::block_next_new()
 
 void FtlImpl_BDftl::print_ftl_statistics()
 {
-	int size = SSD_SIZE * PACKAGE_SIZE * DIE_SIZE * PLANE_SIZE;
-
 	printf("FTL Stats:\n");
-	printf(" Blocks total: %i\n", size);
+	printf(" Blocks total: %i\n", NUMBER_OF_ADDRESSABLE_BLOCKS);
 
 	int numOptimal = 0;
-	for (int i=0;i<size;i++)
+	for (uint i=0;i<NUMBER_OF_ADDRESSABLE_BLOCKS;i++)
 	{
 		BPage bp = block_map[i];
 		if (bp.optimal)

FTLs/bdftl_ftl.cpp

@@ -43,7 +43,7 @@ using namespace ssd;
 FtlImpl_Dftl::FtlImpl_Dftl(Controller &controller):
 	FtlImpl_DftlParent(controller)
 {
-	uint ssdSize = SSD_SIZE * PACKAGE_SIZE * DIE_SIZE * PLANE_SIZE * BLOCK_SIZE;
+	uint ssdSize = NUMBER_OF_ADDRESSABLE_BLOCKS * BLOCK_SIZE;
 
 	printf("Total size to map: %uKB\n", ssdSize * PAGE_SIZE / 1024);
 	printf("Using DFTL.\n");
@@ -153,7 +153,7 @@ void FtlImpl_Dftl::cleanup_block(Event &event, Block *block)
 			// Get new address to write to and invalidate previous
 			Event writeEvent = Event(WRITE, event.get_logical_address(), 1, event.get_start_time()+readEvent.get_time_taken());
 			Address dataBlockAddress = Address(get_free_data_page(event, false), PAGE);
-			Block *entryBlock = controller.get_block_pointer(dataBlockAddress);
+
 			writeEvent.set_address(dataBlockAddress);
 
 			writeEvent.set_replace_address(Address(block->get_physical_address()+i, PAGE));

FTLs/dftl_ftl.cpp

@@ -67,7 +67,7 @@ FtlImpl_DftlParent::FtlImpl_DftlParent(Controller &controller):
 	currentTranslationPage = -1;
 
 	// Detect required number of bits for logical address size
-	addressSize = log(SSD_SIZE * PACKAGE_SIZE * DIE_SIZE * PLANE_SIZE * BLOCK_SIZE)/log(2);
+	addressSize = log(NUMBER_OF_ADDRESSABLE_BLOCKS * BLOCK_SIZE)/log(2);
 
 	// Find required number of bits for block size
 	addressPerPage = (PAGE_SIZE/ceil(addressSize / 8.0)); // 8 bits per byte
@@ -78,7 +78,7 @@ FtlImpl_DftlParent::FtlImpl_DftlParent(Controller &controller):
 	printf("Number of elements in Cached Mapping Table (CMT): %i\n", totalCMTentries);
 
 	// Initialise block mapping table.
-	uint ssdSize = SSD_SIZE * PACKAGE_SIZE * DIE_SIZE * PLANE_SIZE * BLOCK_SIZE;
+	uint ssdSize = NUMBER_OF_ADDRESSABLE_BLOCKS * BLOCK_SIZE;
 
 	trans_map.reserve(ssdSize);
 	for (uint i=0;i<ssdSize;i++)

FTLs/dftl_parent.cpp

@@ -34,17 +34,16 @@ using namespace ssd;
 FtlImpl_Fast::FtlImpl_Fast(Controller &controller):
 	FtlParent(controller)
 {
-	addressSize = log(SSD_SIZE * PACKAGE_SIZE * DIE_SIZE * PLANE_SIZE)/log(2);
+	addressSize = log(NUMBER_OF_ADDRESSABLE_BLOCKS)/log(2);
 	addressShift = log(BLOCK_SIZE)/log(2);
 
 	printf("Total required bits for representation: %i (Address: %i Block: %i) \n", addressSize + addressShift, addressSize, addressShift);
 
 	// Initialise block mapping table.
-	uint numBlocks = SSD_SIZE * PACKAGE_SIZE * DIE_SIZE * PLANE_SIZE;
-	data_list = new long[numBlocks];
-	std::fill_n(data_list, numBlocks, -1);
+	data_list = new long[NUMBER_OF_ADDRESSABLE_BLOCKS];
+	std::fill_n(data_list, NUMBER_OF_ADDRESSABLE_BLOCKS, -1);
 
-	pin_list = new bool[numBlocks*BLOCK_SIZE];
+	pin_list = new bool[NUMBER_OF_ADDRESSABLE_BLOCKS*BLOCK_SIZE];
 
 	// SW
 	sequential_offset = 0;
@@ -54,7 +53,7 @@ FtlImpl_Fast::FtlImpl_Fast(Controller &controller):
 
 	log_pages = NULL;
 
-	printf("Total mapping table size: %luKB\n", numBlocks * sizeof(uint) / 1024);
+	printf("Total mapping table size: %luKB\n", NUMBER_OF_ADDRESSABLE_BLOCKS * sizeof(uint) / 1024);
 	printf("Using FAST FTL.\n");
 }
 
@@ -102,7 +101,7 @@ enum status FtlImpl_Fast::read(Event &event)
 		{
 			//event.incr_time_taken(RAM_READ_DELAY);
 
-			if (currentBlock->aPages[i] == event.get_logical_address())
+			if (currentBlock->aPages[i] == (long)event.get_logical_address())
 			{
 				Address readAddress = Address(currentBlock->address.get_linear_address() + i, PAGE);
 				event.set_address(readAddress);
@@ -201,7 +200,7 @@ enum status FtlImpl_Fast::trim(Event &event)
 	{
 		for (int i=0;i<currentBlock->numPages;i++)
 		{
-			if (currentBlock->aPages[i] == event.get_logical_address())
+			if (currentBlock->aPages[i] == (long)event.get_logical_address())
 			{
 				Address address = Address(currentBlock->address.get_linear_address() + i, PAGE);
 				Block *block = controller.get_block_pointer(address);

FTLs/fast_ftl.cpp

@@ -30,7 +30,7 @@ using namespace ssd;
 FtlImpl_Page::FtlImpl_Page(Controller &controller):
 	FtlParent(controller)
 {
-	trim_map = new bool[SSD_SIZE * PACKAGE_SIZE * DIE_SIZE * PLANE_SIZE * BLOCK_SIZE];
+	trim_map = new bool[NUMBER_OF_ADDRESSABLE_BLOCKS * BLOCK_SIZE];
 
 	numPagesActive = 0;
 
@@ -50,7 +50,7 @@ enum status FtlImpl_Page::read(Event &event)
 
 	controller.stats.numFTLRead++;
 
-	return controller.issue(event);;
+	return controller.issue(event);
 }
 
 enum status FtlImpl_Page::write(Event &event)
@@ -60,7 +60,7 @@ enum status FtlImpl_Page::write(Event &event)
 
 	controller.stats.numFTLWrite++;
 
-	if (numPagesActive == SSD_SIZE * PACKAGE_SIZE * DIE_SIZE * PLANE_SIZE * BLOCK_SIZE)
+	if (numPagesActive == NUMBER_OF_ADDRESSABLE_BLOCKS * BLOCK_SIZE)
 	{
 		numPagesActive -= BLOCK_SIZE;
 

FTLs/page_ftl.cpp

@@ -104,7 +104,7 @@ int main(int argc, char **argv){
 
 	long writeEvent = 0;
 	long readEvent = 0;
-	for (int i=0; i<files.size();i++)
+	for (unsigned int i=0; i<files.size();i++)
 	{
 		char *filename = NULL;
 		asprintf(&filename, "%s%s", argv[1], files[i].c_str());
@@ -192,9 +192,7 @@ int main(int argc, char **argv){
 	unsigned long num_reads = 0;
 	unsigned long num_writes = 0;
 
-	long cnt=0;
-
-	for (int i=0; i<files.size();i++)
+	for (unsigned int i=0; i<files.size();i++)
 	{
 		char *filename = NULL;
 		asprintf(&filename, "%s%s", argv[1], files[i].c_str());

run_ufliptrace.cpp

@@ -83,7 +83,7 @@ MAP_DIRECTORY_SIZE 100
 
 # FTL Implementation to use 0 = Page, 1 = BAST, 
 # 2 = FAST, 3 = DFTL, 4 = Bimodal
-FTL_IMPLEMENTATION 2
+FTL_IMPLEMENTATION 4
 
 # LOG Page limit for BAST
 BAST_LOG_PAGE_LIMIT 1024
@@ -96,3 +96,10 @@ CACHE_DFTL_LIMIT 512
 
 # 0 -> Normal behavior, 1 -> Striping, 2 -> Logical address space parallelism
 PARALLELISM_MODE 0
+
+# Written in round robin: Virtual block size (as a multiple of the physical block size) 
+VIRTUAL_BLOCK_SIZE = 1
+
+# Striping: Virtual page size (as a multiple of the physical page size) 
+VIRTUAL_PAGE_SIZE = 1
+

ssd.conf

@@ -146,8 +146,15 @@ extern const uint CACHE_DFTL_LIMIT;
 /*
  * Parallelism mode
  */
-extern const uint PARALLELISM_MODE = 0;
+extern const uint PARALLELISM_MODE;
 
+/* Virtual block size (as a multiple of the physical block size) */
+extern const uint VIRTUAL_BLOCK_SIZE;
+
+/* Virtual page size (as a multiple of the physical page size) */
+extern const uint VIRTUAL_PAGE_SIZE;
+
+const uint NUMBER_OF_ADDRESSABLE_BLOCKS = SSD_SIZE * PACKAGE_SIZE * DIE_SIZE * PLANE_SIZE / VIRTUAL_PAGE_SIZE;
 /*
  * Memory area to support pages with data.
  */
@@ -386,7 +393,7 @@ class Event
 	double time_taken;
 	double bus_wait_time;
 	enum event_type type;
-	bool noop;
+
 	ulong logical_address;
 	Address address;
 	Address merge_address;
@@ -395,6 +402,7 @@ class Event
 	uint size;
 	void *payload;
 	Event *next;
+	bool noop;
 };
 
 /* Single bus channel
@@ -484,6 +492,8 @@ class Page
 class Block 
 {
 public:
+	long physical_address;
+	uint pages_invalid;
 	Block(const Plane &parent, uint size = BLOCK_SIZE, ulong erases_remaining = BLOCK_ERASES, double erase_delay = BLOCK_ERASE_DELAY, long physical_address = 0);
 	~Block(void);
 	enum status read(Event &event);
@@ -506,8 +516,7 @@ class Block
 	Block *get_pointer(void);
 	block_type get_block_type(void) const;
 	void set_block_type(block_type value);
-	long physical_address;
-	uint pages_invalid;
+
 private:
 	uint size;
 	Page * const data;
@@ -992,6 +1001,7 @@ class Controller
 	const FtlParent &get_ftl(void) const;
 private:
 	enum status issue(Event &event_list);
+	void translate_address(Address &address);
 	ssd::ulong get_erases_remaining(const Address &address) const;
 	void get_least_worn(Address &address) const;
 	double get_last_erase_time(const Address &address) const;

ssd.h

@@ -31,26 +31,29 @@
 using namespace ssd;
 
 Block::Block(const Plane &parent, uint block_size, ulong erases_remaining, double erase_delay, long physical_address):
+	pages_invalid(0),
+	physical_address(physical_address),
 	size(block_size),
 
 	/* use a const pointer (Page * const data) to use as an array
 	 * but like a reference, we cannot reseat the pointer */
 	data((Page *) malloc(block_size * sizeof(Page))),
 	parent(parent),
 	pages_valid(0),
-	pages_invalid(0),
+
 	state(FREE),
-	modification_time(-1),
+
 	/* set erases remaining to BLOCK_ERASES to match Block constructor args 
 	 * in Plane class
 	 * this is the cheap implementation but can change to pass through classes */
-/* 	erases_remaining(BLOCK_ERASES), */
 	erases_remaining(erases_remaining),
 
 	/* assume hardware created at time 0 and had an implied free erasure */
 	last_erase_time(0.0),
 	erase_delay(erase_delay),
-	physical_address(physical_address)
+
+	modification_time(-1)
+
 {
 	uint i;