ssd_block.cpp

/* Copyright 2009, 2010 Brendan Tauras */

/* ssd_block.cpp is part of FlashSim. */

/* 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/>. */

/****************************************************************************/

/* Block class
 * Brendan Tauras 2009-10-26
 *
 * The block is the data storage hardware unit where erases are implemented.
 * Blocks maintain wear statistics for the FTL. */

#include <new>
#include <assert.h>
#include <stdio.h>
#include "ssd.h"

using namespace ssd;

Block::Block(const Plane &parent, uint block_size, ulong erases_remaining, double erase_delay):
	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),

	/* 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)
{
	uint i;

	if(erase_delay < 0.0)
	{
		fprintf(stderr, "Block warning: %s: constructor received negative erase delay value\n\tsetting erase delay to 0.0\n", __func__);
		erase_delay = 0.0;
	}

	/* new cannot initialize an array with constructor args so
	 * 	malloc the array
	 * 	then use placement new to call the constructor for each element
	 * chose an array over container class so we don't have to rely on anything
	 * 	i.e. STL's std::vector */
	/* array allocated in initializer list:
	 * data = (Page *) malloc(size * sizeof(Page)); */
	if(data == NULL){
		fprintf(stderr, "Block error: %s: constructor unable to allocate Page data\n", __func__);
		exit(MEM_ERR);
	}
	for(i = 0; i < size; i++)
		(void) new (&data[i]) Page(*this, PAGE_READ_DELAY, PAGE_WRITE_DELAY);
	return;
}

Block::~Block(void)
{
	assert(data != NULL);
	uint i;
	/* call destructor for each Page array element
	 * since we used malloc and placement new */
	for(i = 0; i < size; i++)
		data[i].~Page();
	free(data);
	return;
}

enum status Block::read(Event &event)
{
	assert(data != NULL);
	return data[event.get_address().page]._read(event);
}

enum status Block::write(Event &event)
{
	assert(data != NULL);
	enum status ret = data[event.get_address().page]._write(event);
	if(ret == SUCCESS)
	{
		pages_valid++;
		state = ACTIVE;
	}
	return ret;
}

/* updates Event time_taken
 * sets Page statuses to EMPTY
 * updates last_erase_time and erases_remaining
 * returns 1 for success, 0 for failure */
enum status Block::_erase(Event &event)
{
	assert(data != NULL && erase_delay >= 0.0);
	uint i;

	if(erases_remaining < 1)
	{
		fprintf(stderr, "Block error: %s: No erases remaining when attempting to erase\n", __func__);
		return FAILURE;
	}

	for(i = 0; i < size; i++)
		data[i].set_state(EMPTY);
	event.incr_time_taken(erase_delay);
	last_erase_time = event.get_start_time() + event.get_time_taken();
	erases_remaining--;
	pages_valid = 0;
	pages_invalid = 0;
	state = FREE;
	return SUCCESS;
}

const Plane &Block::get_parent(void) const
{
	return parent;
}

ssd::uint Block::get_pages_valid(void) const
{
	return pages_valid;
}

ssd::uint Block::get_pages_invalid(void) const
{
	return pages_invalid;
}


enum block_state Block::get_state(void) const
{
	return state;
}

enum page_state Block::get_state(uint page) const
{
	assert(data != NULL && page < size);
	return data[page].get_state();
}

enum page_state Block::get_state(const Address &address) const
{
   assert(data != NULL && address.page < size && address.valid >= BLOCK);
   return data[address.page].get_state();
}

double Block::get_last_erase_time(void) const
{
	return last_erase_time;
}

ssd::ulong Block::get_erases_remaining(void) const
{
	return erases_remaining;
}

ssd::uint Block::get_size(void) const
{
	return size;
}

void Block::invalidate_page(uint page)
{
	assert(page < size);
	data[page].set_state(INVALID);
	pages_invalid++;

	/* update block state */
	if(pages_invalid >= size)
		state = INACTIVE;
	else if(pages_valid > 0 || pages_invalid > 0)
		state = ACTIVE;
	else
		state = FREE;
	
	return;
}

/* method to find the next usable (empty) page in this block
 * method is called by write and erase methods and in Plane::get_next_page() */
enum status Block::get_next_page(Address &address) const
{
	uint i;

	for(i = 0; i < size; i++)
	{
		if(data[i].get_state() == EMPTY)
		{
			address.page = i;
			address.valid = PAGE;
			return SUCCESS;
		}
	}
	return FAILURE;
}