Merge branch 'master' into parallelism

Conflicts:
	run_correctness.cpp

Adding RAID support with striping and Round robin.

Author: MatiasBjorling

.cproject

@@ -31,7 +31,7 @@
 				</dictionary>
 				<dictionary>
 					<key>org.eclipse.cdt.make.core.buildLocation</key>
-					<value>${workspace_loc:/FTL/Trace}</value>
+					<value>${workspace_loc:/FTL/RAID}</value>
 				</dictionary>
 				<dictionary>
 					<key>org.eclipse.cdt.make.core.cleanBuildTarget</key>
@@ -59,7 +59,7 @@
 				</dictionary>
 				<dictionary>
 					<key>org.eclipse.cdt.make.core.stopOnError</key>
-					<value>true</value>
+					<value>false</value>
 				</dictionary>
 				<dictionary>
 					<key>org.eclipse.cdt.make.core.useDefaultBuildCmd</key>

.project

@@ -44,7 +44,6 @@ FtlImpl_Dftl::FtlImpl_Dftl(Controller &controller):
 	FtlImpl_DftlParent(controller)
 {
 	uint ssdSize = NUMBER_OF_ADDRESSABLE_BLOCKS * BLOCK_SIZE;
-
 	printf("Total size to map: %uKB\n", ssdSize * PAGE_SIZE / 1024);
 	printf("Using DFTL.\n");
 	return;

FTLs/dftl_ftl.cpp

@@ -62,7 +62,7 @@ FtlImpl_DftlParent::FtlImpl_DftlParent(Controller &controller):
 	FtlParent(controller)
 {
 	addressPerPage = 0;
-
+	cmt = 0;
 	currentDataPage = -1;
 	currentTranslationPage = -1;
 

FTLs/dftl_parent.cpp

@@ -15,15 +15,18 @@ using namespace ssd;
 
 #define GARBAGEPATH "/home/silverwolf/garbage"
 
+double timings = 0.0;
+
 double do_seq(Ssd *ssd, event_type type, void *test, unsigned int file_size)
 {
 	unsigned int adr, i = 0;
 	double result = 0;
 	for (adr = 0; adr < file_size;adr += PAGE_SIZE)
 	{
-		double iotime = ssd->event_arrive(type, i, 1, (double) adr, (char*)test + adr);
+		double iotime = ssd->event_arrive(type, i, 1, timings, (char*)test + adr);
 		//printf("IO Execution time: %f\n", iotime);
 		result += iotime;
+		timings += iotime;
 		if (type == READ)
 		{
 			if (ssd->get_result_buffer() == NULL)
@@ -43,11 +46,14 @@ double do_seq_backward(Ssd *ssd, event_type type, void *test, unsigned int file_
 	double result = 0;
 	for (adr = file_size; adr > 0;adr -= PAGE_SIZE)
 	{
-		result += ssd->event_arrive(type, j+i, 1, file_size-(double) adr, (char*)test + adr - PAGE_SIZE);
+		double iotime = ssd->event_arrive(type, j+i, 1, timings, (char*)test + adr - PAGE_SIZE);
 
 		if (type == READ && memcmp(ssd->get_result_buffer(), (char*)test + adr - PAGE_SIZE, PAGE_SIZE) != 0)
 			fprintf(stderr, "Err. Data does not compare. i: %i\n", j+i);
 
+		result += iotime;
+		timings += iotime;
+
 		i--;
 
 		if (i == -1u)
@@ -56,7 +62,6 @@ double do_seq_backward(Ssd *ssd, event_type type, void *test, unsigned int file_
 			j += BLOCK_SIZE;
 		}
 	}
-
 	return result;
 }
 
@@ -116,10 +121,12 @@ int main()
 
 	printf("Test 1. Write sequential test data.\n");
 	result += do_seq(ssd, WRITE, test_data, st.st_size);
+//
+//	printf("Test 1. Trim data.\n");
+//	result += do_seq(ssd, TRIM, test_data, st.st_size);
 
-	printf("Test 1. Trim data.\n");
-	result += do_seq(ssd, TRIM, test_data, st.st_size);
-
+	printf("Test 1. Write sequential test data.\n");
+		result += do_seq(ssd, WRITE, test_data, st.st_size);
 
 	printf("Test 2. Read sequential test data.\n");
 	result += do_seq(ssd, READ, test_data, st.st_size);

run_correctness.cpp

@@ -0,0 +1,49 @@
+/* Copyright 2012 Matias Bjørling */
+
+/* FlashSim is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * any later version. */
+
+/* FlashSim is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details. */
+
+/* You should have received a copy of the GNU General Public License
+ * along with FlashSim.  If not, see <http://www.gnu.org/licenses/>. */
+
+/****************************************************************************/
+
+#include "ssd.h"
+
+#define SIZE 10
+
+using namespace ssd;
+
+int main()
+{
+	load_config();
+	print_config(NULL);
+
+	RaidSsd *ssd = new RaidSsd();
+
+	double result;
+	double cur_time = 1;
+
+	for (int i = 0; i < SIZE; i++)
+	{
+		result = ssd -> event_arrive(WRITE, i*2, 1, 0);
+		cur_time += result;
+	}
+	for (int i = 0; i < SIZE; i++)
+	{
+		result = ssd -> event_arrive(READ, i*2, 1, 0);
+		cur_time += result;
+	}
+
+	printf("Total execution time %f\n", cur_time);
+
+	delete ssd;
+	return 0;
+}

run_raid.cpp

@@ -38,23 +38,23 @@ BUS_TABLE_SIZE 512
 
 # Ssd class:
 #    number of Packages per Ssd (size)
-SSD_SIZE 4
+SSD_SIZE 1
 
 # Package class:
 #    number of Dies per Package (size)
-PACKAGE_SIZE 2
+PACKAGE_SIZE 1
 
 # Die class:
 #    number of Planes per Die (size)
-DIE_SIZE 2
+DIE_SIZE 1
 
 # Plane class:
 #    number of Blocks per Plane (size)
 #    delay for reading from plane register
 #    delay for writing to plane register
 #    delay for merging is based on read, write, reg_read, reg_write 
 #       and does not need to be explicitly defined
-PLANE_SIZE 2048
+PLANE_SIZE 256
 PLANE_REG_READ_DELAY 0.01
 PLANE_REG_WRITE_DELAY 0.01
 
@@ -74,7 +74,7 @@ BLOCK_ERASE_DELAY 2000
 #    Size of pages (in bytes)
 PAGE_READ_DELAY 25
 PAGE_WRITE_DELAY 300
-PAGE_ENABLE_DATA 2048
+PAGE_ENABLE_DATA 1
 
 # MAPPING 
 # Specify reservation of 
@@ -83,7 +83,7 @@ MAP_DIRECTORY_SIZE 100
 
 # FTL Implementation to use 0 = Page, 1 = BAST, 
 # 2 = FAST, 3 = DFTL, 4 = Bimodal
-FTL_IMPLEMENTATION 4
+FTL_IMPLEMENTATION 3
 
 # LOG Page limit for BAST
 BAST_LOG_PAGE_LIMIT 1024
@@ -95,11 +95,14 @@ FAST_LOG_PAGE_LIMIT 1024
 CACHE_DFTL_LIMIT 512
 
 # 0 -> Normal behavior, 1 -> Striping, 2 -> Logical address space parallelism
-PARALLELISM_MODE 0
+PARALLELISM_MODE 2
 
 # Written in round robin: Virtual block size (as a multiple of the physical block size) 
-VIRTUAL_BLOCK_SIZE = 1
+VIRTUAL_BLOCK_SIZE 1
 
 # Striping: Virtual page size (as a multiple of the physical page size) 
-VIRTUAL_PAGE_SIZE = 1
+VIRTUAL_PAGE_SIZE 1
+
+# RAISSDs: Number of physical SSDs 
+RAID_NUMBER_OF_PHYSICAL_SSDS 2
 

ssd.conf

@@ -154,7 +154,11 @@ 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;
+extern const uint NUMBER_OF_ADDRESSABLE_BLOCKS;
+
+/* RAISSDs: Number of physical SSDs */
+extern const uint RAID_NUMBER_OF_PHYSICAL_SSDS;
+
 /*
  * Memory area to support pages with data.
  */
@@ -726,10 +730,6 @@ class Block_manager
 	std::vector<Block*> free_list;
 	std::vector<Block*> invalid_list;
 
-	// Until all pages have been requested, we serve them from a linear
-	// address space.
-	ulong simpleCurrentFree;
-
 	// Counter for returning the next free page.
 	ulong directoryCurrentPage;
 	// Address on the current cached page in SRAM.
@@ -1066,6 +1066,28 @@ class Ssd
 	double last_erase_time;
 };
 
+class RaidSsd
+{
+public:
+	RaidSsd (uint ssd_size = SSD_SIZE);
+	~RaidSsd(void);
+	double event_arrive(enum event_type type, ulong logical_address, uint size, double start_time);
+	double event_arrive(enum event_type type, ulong logical_address, uint size, double start_time, void *buffer);
+	void *get_result_buffer();
+	friend class Controller;
+	void print_statistics();
+	void reset_statistics();
+	void write_statistics(FILE *stream);
+	void write_header(FILE *stream);
+	const Controller &get_controller(void) const;
+
+	void print_ftl_statistics();
+private:
+	uint size;
+
+	Ssd *Ssds;
+
+};
 } /* end namespace ssd */
 
 #endif

ssd.h

@@ -36,7 +36,6 @@ Block_manager::Block_manager(FtlParent *ftl) : ftl(ftl)
 	max_map_pages = MAP_DIRECTORY_SIZE * BLOCK_SIZE;
 
 	directoryCurrentPage = 0;
-	simpleCurrentFree = 0;
 	num_insert_events = 0;
 
 	data_active = 0;
@@ -76,13 +75,15 @@ Block_manager *Block_manager::instance()
  */
 void Block_manager::get_page_block(Address &address, Event &event)
 {
-	if (simpleCurrentFree < max_blocks*BLOCK_SIZE)
-	{
-		address.set_linear_address(simpleCurrentFree, BLOCK);
-		current_writing_block = simpleCurrentFree;
-		simpleCurrentFree += BLOCK_SIZE;
-	}
-	else
+	// We need separate queues for each plane? communication channel? communication channel is at the per die level at the moment. i.e. each LUN is a die.
+//
+//	if (simpleCurrentFree < max_blocks*BLOCK_SIZE)
+//	{
+//		address.set_linear_address(simpleCurrentFree, BLOCK);
+//		current_writing_block = simpleCurrentFree;
+//		simpleCurrentFree += BLOCK_SIZE;
+//	}
+//	else
 	{
 		if (free_list.size() <= 1 && !out_of_blocks)
 		{
@@ -137,7 +138,7 @@ void Block_manager::print_statistics()
 	printf("-----------------\n");
 	printf("Log blocks:  %lu\n", log_active);
 	printf("Data blocks: %lu\n", data_active);
-	printf("Free blocks: %lu\n", (max_blocks - (simpleCurrentFree/BLOCK_SIZE)) + free_list.size());
+//	printf("Free blocks: %lu\n", (max_blocks - (simpleCurrentFree/BLOCK_SIZE)) + free_list.size());
 	printf("Invalid blocks: %lu\n", invalid_list.size());
 	printf("Free2 blocks: %lu\n", (unsigned long int)invalid_list.size() + (unsigned long int)log_active + (unsigned long int)data_active - (unsigned long int)free_list.size());
 	printf("-----------------\n");
@@ -202,6 +203,8 @@ void Block_manager::insert_events(Event &event)
 
 		ActiveByCost::iterator it = active_cost.get<1>().end();
 		--it;
+
+
 		while (num_to_erase != 0 && (*it)->get_pages_invalid() > 0 && (*it)->get_pages_valid() == BLOCK_SIZE)
 		{
 			if (current_writing_block != (*it)->physical_address)
@@ -311,10 +314,11 @@ void Block_manager::erase_and_invalidate(Event &event, Address &address, block_t
 
 int Block_manager::get_num_free_blocks()
 {
-	if (simpleCurrentFree < max_blocks*BLOCK_SIZE)
-		return (simpleCurrentFree / BLOCK_SIZE) + free_list.size();
-	else
-		return free_list.size();
+
+//	if (simpleCurrentFree < max_blocks*BLOCK_SIZE)
+//		return (simpleCurrentFree / BLOCK_SIZE) + free_list.size();
+//	else
+//		return free_list.size();
 }
 
 void Block_manager::update_block(Block * b)

ssd_bm.cpp

@@ -167,6 +167,11 @@ uint VIRTUAL_BLOCK_SIZE = 1;
 /* Virtual page size (as a multiple of the physical page size) */
 uint VIRTUAL_PAGE_SIZE = 1;
 
+uint NUMBER_OF_ADDRESSABLE_BLOCKS = 0;
+
+/* RAISSDs: Number of physical SSDs */
+uint RAID_NUMBER_OF_PHYSICAL_SSDS = 0;
+
 void load_entry(char *name, double value, uint line_number) {
 	/* cheap implementation - go through all possibilities and match entry */
 	if (!strcmp(name, "RAM_READ_DELAY"))
@@ -225,6 +230,8 @@ void load_entry(char *name, double value, uint line_number) {
 		VIRTUAL_BLOCK_SIZE = value;
 	else if (!strcmp(name, "VIRTUAL_PAGE_SIZE"))
 		VIRTUAL_PAGE_SIZE = value;
+	else if (!strcmp(name, "RAID_NUMBER_OF_PHYSICAL_SSDS"))
+		RAID_NUMBER_OF_PHYSICAL_SSDS = value;
 	else
 		fprintf(stderr, "Config file parsing error on line %u\n", line_number);
 	return;
@@ -263,6 +270,9 @@ void load_config(void) {
 					line_number);
 	}
 	fclose(config_file);
+
+	NUMBER_OF_ADDRESSABLE_BLOCKS = (SSD_SIZE * PACKAGE_SIZE * DIE_SIZE * PLANE_SIZE) / VIRTUAL_PAGE_SIZE;
+
 	return;
 }
 
@@ -291,6 +301,8 @@ void print_config(FILE *stream) {
 	fprintf(stream, "MAP_DIRECTORY_SIZE: %i\n", MAP_DIRECTORY_SIZE);
 	fprintf(stream, "FTL_IMPLEMENTATION: %i\n", FTL_IMPLEMENTATION);
 	fprintf(stream, "PARALLELISM_MODE: %i\n", PARALLELISM_MODE);
+	fprintf(stream, "RAID_NUMBER_OF_PHYSICAL_SSDS: %i\n", RAID_NUMBER_OF_PHYSICAL_SSDS);
+
 	return;
 }
 

ssd_config.cpp

@@ -31,6 +31,9 @@ Block_manager *Block_manager::inst = NULL;
 FtlParent::FtlParent(Controller &controller) : controller(controller)
 {
 	Block_manager::instance_initialize(this);
+
+	printf("Number of addressable blocks: %u\n", NUMBER_OF_ADDRESSABLE_BLOCKS);
+
 }