static void ssd_request_arrive (ioreq_event *curr)
{
ssd_t *currdisk;
// fprintf (outputfile, "Entering ssd_request_arrive: %12.6f\n", simtime);
// fprintf (outputfile, "ssd = %d, blkno = %d, bcount = %d, read = %d\n",curr->devno, curr->blkno, curr->bcount, (READ & curr->flags));
currdisk = getssd(curr->devno);
// verify that request is valid.
if ((curr->blkno < 0) || (curr->bcount <= 0) ||
((curr->blkno + curr->bcount) > currdisk->numblocks)) {
fprintf(outputfile3, "Invalid set of blocks requested from ssd - blkno %d, bcount %d, numblocks %d\n", curr->blkno, curr->bcount, currdisk->numblocks);
exit(1);
}
/* create a new request, set it up for initial interrupt */
ioqueue_add_new_request(currdisk->queue, curr);
if (currdisk->channel_activity == NULL) {
curr = ioqueue_get_next_request(currdisk->queue);
currdisk->busowned = ssd_get_busno(curr);
currdisk->channel_activity = curr;
currdisk->reconnect_reason = IO_INTERRUPT_ARRIVE;
if (curr->flags & READ) {
ssd_media_access_request (curr);
ssd_check_channel_activity(currdisk);
} else {
curr->cause = READY_TO_TRANSFER;
curr->type = IO_INTERRUPT_ARRIVE;
ssd_send_event_up_path(curr, currdisk->bus_transaction_latency);
}
}
}
double ssd_get_blktranstime (ioreq_event *curr)
{
ssd_t *currdisk;
double tmptime;
currdisk = getssd (curr->devno);
tmptime = bus_get_transfer_time(ssd_get_busno(curr), 1, (curr->flags & READ));
if (tmptime < currdisk->blktranstime) {
tmptime = currdisk->blktranstime;
}
return(tmptime);
}
/*
* ssd_send_event_up_path()
*
* Acquires the bus (if not already acquired), then uses bus_delay to
* send the event up the path.
*
* If the bus is already owned by this device or can be acquired
* immediately (interleaved bus), the event is sent immediately.
* Otherwise, ssd_bus_ownership_grant will later send the event.
*/
static void ssd_send_event_up_path (ioreq_event *curr, double delay)
{
ssd_t *currdisk;
int busno;
int slotno;
// fprintf (outputfile, "ssd_send_event_up_path - devno %d, type %d, cause %d, blkno %d\n", curr->devno, curr->type, curr->cause, curr->blkno);
currdisk = getssd (curr->devno);
ssd_assert_current_activity(currdisk, curr);
busno = ssd_get_busno(curr);
slotno = currdisk->slotno[0];
/* Put new request at head of buswait queue */
curr->next = currdisk->buswait;
currdisk->buswait = curr;
curr->tempint1 = busno;
curr->time = delay;
if (currdisk->busowned == -1) {
// fprintf (outputfile, "Must get ownership of the bus first\n");
if (curr->next) {
//fprintf(stderr,"Multiple bus requestors detected in ssd_send_event_up_path\n");
/* This should be ok -- counting on the bus module to sequence 'em */
}
if (bus_ownership_get(busno, slotno, curr) == FALSE) {
/* Remember when we started waiting (only place this is written) */
currdisk->stat.requestedbus = simtime;
} else {
currdisk->busowned = busno;
bus_delay(busno, DEVICE, curr->devno, delay, curr); /* Never for SCSI */
}
} else if (currdisk->busowned == busno) {
//fprintf (outputfile, "Already own bus - so send it on up\n");
bus_delay(busno, DEVICE, curr->devno, delay, curr);
} else {
fprintf(stderr, "Wrong bus owned for transfer desired\n");
exit(1);
}
}
