static void controller_smart_access_complete (controller *currctlr, ioreq_event *curr)
{
struct ioq *queue = currctlr->devices[curr->devno].queue;
ioreq_event *done = ioreq_copy(curr);
int devno = curr->devno;
int numout;
/* Responds to completion interrupt */
done->type = IO_INTERRUPT_COMPLETE;
currctlr->outbusowned = controller_get_downward_busno(currctlr, done, NULL);
controller_send_event_down_path(currctlr, done, currctlr->ovrhd_disk_complete);
currctlr->outbusowned = -1;
/* Handles request completion, including call-backs into cache */
curr = ioqueue_physical_access_done(queue, curr);
while ((done = curr)) {
curr = curr->next;
/* call back into cache with completion -- let it do request_complete */
controller_smart_wakeup(currctlr, currctlr->cache->cache_disk_access_complete(currctlr->cache, done));
}
/* Initiate another request, if any pending */
numout = ioqueue_get_reqoutstanding(queue);
if ((numout < currctlr->devices[devno].maxoutstanding) && (curr = ioqueue_get_next_request(queue))) {
controller_send_event_down_path(currctlr, curr, currctlr->ovrhd_disk_request);
}
}
static void ssd_access_complete_element(ioreq_event *curr)
{
ssd_t *currdisk;
int elem_num;
ssd_element *elem;
ioreq_event *x;
currdisk = getssd (curr->devno);
elem_num = currdisk->timing_t->choose_element(currdisk->timing_t, curr->blkno);
ASSERT(elem_num == curr->ssd_elem_num);
elem = &currdisk->elements[elem_num];
if ((x = ioqueue_physical_access_done(elem->queue,curr)) == NULL) {
fprintf(stderr, "ssd_access_complete: ioreq_event not found by ioqueue_physical_access_done call\n");
exit(1);
}
// all the reqs are over
if (ioqueue_get_reqoutstanding(elem->queue) == 0) {
elem->media_busy = FALSE;
}
ssd_complete_parent(curr, currdisk);
addtoextraq((event *) curr);
ssd_activate_elem(currdisk, elem_num);
}
static void ssd_access_complete_element(ioreq_event *curr)
{
ssd_t *currdisk;
int elem_num;
ssd_element *elem;
ioreq_event *x;
int lba;
currdisk = getssd (curr->devno);
elem_num = ssd_choose_element(currdisk->user_params, curr->blkno);
ASSERT(elem_num == curr->ssd_elem_num);
elem = &currdisk->elements[elem_num];
lba = ssd_logical_pageno(curr->blkno, currdisk);
if(curr->flags & READ){
fprintf(outputfile5, "%10.6f %d %d %d\n", simtime, lba, elem_num, curr->blkno);
}
else {
fprintf(outputfile4, "%10.6f %d %d %d\n", simtime, lba, elem_num, curr->blkno);
}
if ((x = ioqueue_physical_access_done(elem->queue,curr)) == NULL) {
fprintf(stderr, "ssd_access_complete: ioreq_event not found by ioqueue_physical_access_done call\n");
exit(1);
}
ssd_dpower(currdisk, 0);
// all the reqs are over
if (ioqueue_get_reqoutstanding(elem->queue) == 0) {
elem->media_busy = FALSE;
}
ssd_complete_parent(curr, currdisk);
addtoextraq((event *) curr);
// added by tiel
// activate request create simtime, type, elem_num
//{
// ioreq_event *temp = (ioreq_event *)getfromextraq();
// temp->type = SSD_ACTIVATE_ELEM;
// temp->time = simtime + (2*currdisk->params.channel_switch_delay);
// //temp->time = simtime;
// temp->ssd_elem_num = elem_num;
// addtointq ((event *)temp);
//}
//printf("time %f \n",simtime);
ssd_activate_elem(currdisk, elem_num);
}
static void simpledisk_request_complete(ioreq_event *curr)
{
simpledisk_t *currdisk;
// fprintf (outputfile, "Entering simpledisk_request_complete: %12.6f\n", simtime);
currdisk = getsimpledisk (curr->devno);
if ((curr = ioqueue_physical_access_done(currdisk->queue,curr)) == NULL) {
fprintf(stderr, "simpledisk_request_complete: ioreq_event not found by ioqueue_physical_access_done call\n");
exit(1);
}
/* send completion interrupt */
curr->type = IO_INTERRUPT_ARRIVE;
curr->cause = COMPLETION;
simpledisk_send_event_up_path(curr, currdisk->bus_transaction_latency);
}
static void simpledisk_request_complete(ioreq_event *curr)
{
simpledisk_t *currdisk;
#ifdef DEBUG_SIMPLEDISK
fprintf (outputfile, "*** %f: simpledisk_request_complete - devno %d, type %d, cause %d, blkno %d\n", simtime, curr->devno, curr->type, curr->cause, curr->blkno);
#endif
currdisk = getsimpledisk (curr->devno);
if ((curr = ioqueue_physical_access_done(currdisk->queue,curr)) == NULL) {
fprintf(stderr, "simpledisk_request_complete: ioreq_event not found by ioqueue_physical_access_done call\n");
exit(1);
}
/* send completion interrupt */
curr->type = IO_INTERRUPT_ARRIVE;
curr->cause = COMPLETION;
simpledisk_send_event_up_path(curr, currdisk->bus_transaction_latency);
}
/*
* send completion up the line
*/
static void ssd_request_complete(ioreq_event *curr)
{
ssd_t *currdisk;
ioreq_event *x;
// fprintf (outputfile, "Entering ssd_request_complete: %12.6f\n", simtime);
currdisk = getssd (curr->devno);
ssd_assert_current_activity(currdisk, curr);
//fprintf(outputfile4, "%10.6f,%d\n", simtime, curr->blkno);
if ((x = ioqueue_physical_access_done(currdisk->queue,curr)) == NULL) {
fprintf(outputfile3, "ssd_request_complete: ioreq_event not found by ioqueue_physical_access_done call\n");
exit(1);
}
/* send completion interrupt */
curr->type = IO_INTERRUPT_ARRIVE;
curr->cause = COMPLETION;
ssd_send_event_up_path(curr, currdisk->bus_transaction_latency);
}
/*
* send completion up the line
*/
static void ssd_request_complete(ioreq_event *curr)
{
ssd_t *currdisk;
ioreq_event *x;
static int i = 0;
//fprintf (outputfile6, "%12.6f %d %d\n", simtime, i++, curr->flags);
currdisk = getssd (curr->devno);
ssd_assert_current_activity(currdisk, curr);
if ((x = ioqueue_physical_access_done(currdisk->queue,curr)) == NULL) {
fprintf(stderr, "ssd_request_complete: ioreq_event not found by ioqueue_physical_access_done call\n");
exit(1);
}
//fprintf(outputfile6, "%d %.6f %d %d %d\n", i++, disksim->lastphystime, curr->blkno, curr->flags);
/* send completion interrupt */
curr->type = IO_INTERRUPT_ARRIVE;
curr->cause = COMPLETION;
ssd_send_event_up_path(curr, currdisk->bus_transaction_latency);
}
static void ssd_access_complete_element(ioreq_event *curr)
{
ssd_t *currdisk;
int elem_num;
ssd_element *elem;
ioreq_event *x;
int lba;
currdisk = getssd (curr->devno);
elem_num = ssd_choose_element(currdisk->user_params, curr->blkno);
ASSERT(elem_num == curr->ssd_elem_num);
elem = &currdisk->elements[elem_num];
lba = ssd_logical_blockno(curr->blkno, currdisk);
if(curr->flags & READ){
fprintf(outputfile5, "%10.6f %d %d %d\n", simtime, lba, elem_num, curr->blkno);
}
else {
fprintf(outputfile4, "%10.6f %d %d %d\n", simtime, lba, elem_num, curr->blkno);
}
if ((x = ioqueue_physical_access_done(elem->queue,curr)) == NULL) {
fprintf(stderr, "ssd_access_complete: ioreq_event not found by ioqueue_physical_access_done call\n");
exit(1);
}
ssd_dpower(currdisk, 0);
// all the reqs are over
if (ioqueue_get_reqoutstanding(elem->queue) == 0) {
elem->media_busy = FALSE;
}
ssd_complete_parent(curr, currdisk);
addtoextraq((event *) curr);
ssd_activate_elem(currdisk, elem_num);
}
void iodriver_access_complete (int iodriverno, intr_event *intrp)
{
int i;
int numreqs;
ioreq_event *tmp;
ioreq_event *del;
ioreq_event *req;
int devno;
int skip = 0;
ctlr *ctl = NULL;
time_t now;
if (iodrivers[iodriverno]->type == STANDALONE) {
req = ioreq_copy((ioreq_event *) intrp->infoptr);
}
else {
req = (ioreq_event *) intrp->infoptr;
}
#ifdef DEBUG_IODRIVER
fprintf (outputfile, "*** %f: iodriver_access_complete - devno %d, blkno %d, bcount %d, read %d\n", simtime, req->devno, req->blkno, req->bcount, (req->flags & READ));
fflush(outputfile);
#endif
time( & now );
disksim_exectrace( "Request completion: simtime %f, devno %d, blkno %lld, bcount %d, flags %X, time %s\n", simtime, req->devno, req->blkno, req->bcount, req->flags, asctime( localtime(& now)) );
if (iodrivers[iodriverno]->devices[(req->devno)].queuectlr != -1)
{
int ctlrno = iodrivers[iodriverno]->devices[(req->devno)].queuectlr;
ctl = &iodrivers[iodriverno]->ctlrs[ctlrno];
tmp = ctl->oversized;
numreqs = 1;
while (((numreqs) || (tmp != ctl->oversized))
&& (tmp)
&& (tmp->next)
&& ((tmp->next->devno != req->devno)
|| (tmp->next->opid != req->opid)
|| (req->blkno < tmp->next->blkno)
|| (req->blkno >= (tmp->next->blkno + tmp->next->bcount))))
{
// fprintf (outputfile, "oversized request in list: opid %d, blkno %lld, bcount %d\n", tmp->opid, tmp->blkno, tmp->bcount);
numreqs = 0;
tmp = tmp->next;
}
if ((tmp)
&& (tmp->next->devno == req->devno)
&& (tmp->next->opid == req->opid)
&& (req->blkno >= tmp->next->blkno)
&& (req->blkno < (tmp->next->blkno + tmp->next->bcount)))
{
fprintf (outputfile, "%f, part of oversized request completed: opid %d, blkno %lld, bcount %d, maxreqsize %d\n", simtime, req->opid, req->blkno, req->bcount, ctl->maxreqsize);
if ((req->blkno + ctl->maxreqsize) < (tmp->next->blkno + tmp->next->bcount))
{
fprintf (outputfile, "more to go\n");
req->blkno += ctl->maxreqsize;
req->bcount = min(ctl->maxreqsize,
(tmp->next->blkno + tmp->next->bcount - req->blkno));
goto schedule_next;
}
else {
fprintf (outputfile, "done for real\n");
addtoextraq((event *) req);
req = tmp->next;
tmp->next = tmp->next->next;
if (ctl->oversized == req) {
ctl->oversized = (req != req->next) ? req->next : NULL;
}
req->next = NULL;
}
}
}
devno = req->devno;
req = ioqueue_physical_access_done(iodrivers[iodriverno]->devices[devno].queue, req);
if (ctl) {
ctl->numoutstanding--;
}
// special case for validate:
if (disksim->traceformat == VALIDATE) {
tmp = (ioreq_event *) getfromextraq();
io_validate_do_stats1();
tmp = iotrace_validate_get_ioreq_event(disksim->iotracefile, tmp);
if (tmp) {
io_validate_do_stats2(tmp);
tmp->type = IO_REQUEST_ARRIVE;
addtointq((event *) tmp);
disksim_exectrace("Request issue: simtime %f, devno %d, blkno %lld, time %f\n",
simtime, tmp->devno, tmp->blkno, tmp->time);
}
else {
disksim_simstop();
}
}
else if (disksim->closedios) {
tmp = (ioreq_event *) io_get_next_external_event(disksim->iotracefile);
if (tmp) {
io_using_external_event ((event *)tmp);
tmp->time = simtime + disksim->closedthinktime;
tmp->type = IO_REQUEST_ARRIVE;
addtointq((event *) tmp);
} else {
disksim_simstop();
}
}
while (req) {
tmp = req;
req = req->next;
tmp->next = NULL;
update_iodriver_statistics();
if ((numreqs = logorg_mapcomplete(sysorgs, numsysorgs, tmp)) == COMPLETE) {
/* update up overall I/O system stats for this completed request */
ioreq_event *temp = ioqueue_get_specific_request (OVERALLQUEUE, tmp);
ioreq_event *temp2 = ioqueue_physical_access_done (OVERALLQUEUE, temp);
ASSERT (temp2 != NULL);
addtoextraq((event *)temp);
temp = NULL;
if (iodrivers[iodriverno]->type != STANDALONE) {
iodriver_add_to_intrp_eventlist(intrp,
io_done_notify(tmp),
iodrivers[iodriverno]->scale);
} else {
io_done_notify (tmp);
}
}
else if (numreqs > 0) {
for (i = 0; i < numreqs; i++) {
del = tmp->next;
tmp->next = del->next;
del->next = NULL;
del->type = IO_REQUEST_ARRIVE;
del->flags |= MAPPED;
skip |= (del->devno == devno);
if (iodrivers[iodriverno]->type == STANDALONE)
{
del->time += simtime + 0.0000000001; /* to affect an ordering */
addtointq((event *) del);
}
else {
iodriver_add_to_intrp_eventlist(intrp,
(event *) del,
iodrivers[iodriverno]->scale);
}
}
}
addtoextraq((event *) tmp);
}
if ((iodrivers[iodriverno]->consttime == IODRIVER_TRACED_QUEUE_TIMES)
|| (iodrivers[iodriverno]->consttime == IODRIVER_TRACED_BOTH_TIMES))
{
if (ioqueue_get_number_in_queue(iodrivers[iodriverno]->devices[devno].queue) > 0)
{
iodrivers[iodriverno]->devices[devno].flag = 1;
iodrivers[iodriverno]->devices[devno].lastevent = simtime;
}
return;
}
if (skip) {
return;
}
// fprintf(outputfile, "iodriver_access_complete:: calling ioqueue_get_next_request\n");
req = ioqueue_get_next_request(iodrivers[iodriverno]->devices[devno].queue);
// fprintf (outputfile, "next scheduled: req %p, req->blkno %d, req->flags %x\n", req, ((req) ? req->blkno : 0), ((req) ? req->flags : 0));
schedule_next:
if (req) {
req->type = IO_ACCESS_ARRIVE;
req->next = NULL;
if (ctl) {
ctl->numoutstanding++;
}
if (iodrivers[iodriverno]->type == STANDALONE) {
req->time = simtime;
addtointq((event *) req);
}
else {
iodriver_add_to_intrp_eventlist(intrp,
(event *) req,
iodrivers[iodriverno]->scale);
}
}
}
