rf_sstf.c

RAIDFrame是个非常好的磁盘阵列RAID仿真工具

	}
	else {
		/* dequeue from middle of list */
		RF_ASSERT(req->next);
		RF_ASSERT(req->prev);
		queue->qlen--;
		req->next->prev = req->prev;
		req->prev->next = req->next;
		req->next = req->prev = NULL;
	}
}

RF_DiskQueueData_t *rf_SstfDequeue(qptr)
  void  *qptr;
{
	RF_DiskQueueData_t *req;
	RF_Sstf_t *sstfq;

	sstfq = (RF_Sstf_t *)qptr;

	if (rf_sstfDebug) {
		RF_DiskQueue_t *dq;
		int tid;
		rf_get_threadid(tid);
		dq = (RF_DiskQueue_t *)req->queue;
		RF_ASSERT(QSUM(sstfq)==dq->queueLength);
		printf("[%d] sstf: Dequeue %d,%d queues are %d,%d,%d\n", tid,
			dq->row, dq->col, sstfq->left.qlen, sstfq->right.qlen,
			sstfq->lopri.qlen);
	}
	if (sstfq->left.queue == NULL) {
		RF_ASSERT(sstfq->left.qlen == 0);
		if (sstfq->right.queue == NULL) {
			RF_ASSERT(sstfq->right.qlen == 0);
			if (sstfq->lopri.queue == NULL) {
				RF_ASSERT(sstfq->lopri.qlen == 0);
				return(NULL);
			}
			if (rf_sstfDebug) {
				int tid;
				rf_get_threadid(tid);
				printf("[%d] sstf: check for close lopri", tid);
			}
			req = closest_to_arm(&sstfq->lopri, sstfq->last_sector,
				&sstfq->dir, sstfq->allow_reverse);
			if (rf_sstfDebug) {
				int tid;
				rf_get_threadid(tid);
				printf("[%d] sstf: closest_to_arm said %lx", tid, req);
			}
			if (req == NULL)
				return(NULL);
			do_dequeue(&sstfq->lopri, req);
		}
		else {
			DO_BEST_DEQ(sstfq->last_sector,req,&sstfq->right);
		}
	}
	else {
		if (sstfq->right.queue == NULL) {
			RF_ASSERT(sstfq->right.qlen == 0);
			DO_BEST_DEQ(sstfq->last_sector,req,&sstfq->left);
		}
		else {
			if (SNUM_DIFF(sstfq->last_sector,sstfq->right.queue->sectorOffset)
				< SNUM_DIFF(sstfq->last_sector,sstfq->left.qtail->sectorOffset))
			{
				DO_HEAD_DEQ(req,&sstfq->right);
			}
			else {
				DO_TAIL_DEQ(req,&sstfq->left);
			}
		}
	}
	RF_ASSERT(req);
	sstfq->last_sector = req->sectorOffset;
	return(req);
}

RF_DiskQueueData_t *rf_ScanDequeue(qptr)
  void  *qptr;
{
	RF_DiskQueueData_t *req;
	RF_Sstf_t *scanq;

	scanq = (RF_Sstf_t *)qptr;

	if (rf_scanDebug) {
		RF_DiskQueue_t *dq;
		int tid;
		rf_get_threadid(tid);
		dq = (RF_DiskQueue_t *)req->queue;
		RF_ASSERT(QSUM(scanq)==dq->queueLength);
		printf("[%d] scan: Dequeue %d,%d queues are %d,%d,%d\n", tid,
			dq->row, dq->col, scanq->left.qlen, scanq->right.qlen,
			scanq->lopri.qlen);
	}
	if (scanq->left.queue == NULL) {
		RF_ASSERT(scanq->left.qlen == 0);
		if (scanq->right.queue == NULL) {
			RF_ASSERT(scanq->right.qlen == 0);
			if (scanq->lopri.queue == NULL) {
				RF_ASSERT(scanq->lopri.qlen == 0);
				return(NULL);
			}
			req = closest_to_arm(&scanq->lopri, scanq->last_sector,
				&scanq->dir, scanq->allow_reverse);
			if (req == NULL)
				return(NULL);
			do_dequeue(&scanq->lopri, req);
		}
		else {
			scanq->dir = DIR_RIGHT;
			DO_HEAD_DEQ(req,&scanq->right);
		}
	}
	else if (scanq->right.queue == NULL) {
		RF_ASSERT(scanq->right.qlen == 0);
		RF_ASSERT(scanq->left.queue);
		scanq->dir = DIR_LEFT;
		DO_TAIL_DEQ(req,&scanq->left);
	}
	else {
		RF_ASSERT(scanq->right.queue);
		RF_ASSERT(scanq->left.queue);
		if (scanq->dir == DIR_RIGHT) {
			DO_HEAD_DEQ(req,&scanq->right);
		}
		else {
			DO_TAIL_DEQ(req,&scanq->left);
		}
	}
	RF_ASSERT(req);
	scanq->last_sector = req->sectorOffset;
	return(req);
}

RF_DiskQueueData_t *rf_CscanDequeue(qptr)
  void  *qptr;
{
	RF_DiskQueueData_t *req;
	RF_Sstf_t *cscanq;

	cscanq = (RF_Sstf_t *)qptr;

	RF_ASSERT(cscanq->dir == DIR_RIGHT);
	if (rf_cscanDebug) {
		RF_DiskQueue_t *dq;
		int tid;
		rf_get_threadid(tid);
		dq = (RF_DiskQueue_t *)req->queue;
		RF_ASSERT(QSUM(cscanq)==dq->queueLength);
		printf("[%d] scan: Dequeue %d,%d queues are %d,%d,%d\n", tid,
			dq->row, dq->col, cscanq->left.qlen, cscanq->right.qlen,
			cscanq->lopri.qlen);
	}
	if (cscanq->right.queue) {
		DO_HEAD_DEQ(req,&cscanq->right);
	}
	else {
		RF_ASSERT(cscanq->right.qlen == 0);
		if (cscanq->left.queue == NULL) {
			RF_ASSERT(cscanq->left.qlen == 0);
			if (cscanq->lopri.queue == NULL) {
				RF_ASSERT(cscanq->lopri.qlen == 0);
				return(NULL);
			}
			req = closest_to_arm(&cscanq->lopri, cscanq->last_sector,
				&cscanq->dir, cscanq->allow_reverse);
			if (req == NULL)
				return(NULL);
			do_dequeue(&cscanq->lopri, req);
		}
		else {
			/*
			 * There's I/Os to the left of the arm. Swing
			 * on back (swap queues).
			 */
			cscanq->right = cscanq->left;
			cscanq->left.qlen = 0;
			cscanq->left.queue = cscanq->left.qtail = NULL;
			DO_HEAD_DEQ(req,&cscanq->right);
		}
	}
	RF_ASSERT(req);
	cscanq->last_sector = req->sectorOffset;
	return(req);
}

RF_DiskQueueData_t *rf_SstfPeek(qptr)
  void  *qptr;
{
	RF_DiskQueueData_t *req;
	RF_Sstf_t *sstfq;

	sstfq = (RF_Sstf_t *)qptr;

	if ((sstfq->left.queue == NULL) && (sstfq->right.queue == NULL)) {
		req = closest_to_arm(&sstfq->lopri, sstfq->last_sector, &sstfq->dir,
			sstfq->allow_reverse);
	}
	else {
		if (sstfq->left.queue == NULL)
			req = sstfq->right.queue;
		else {
			if (sstfq->right.queue == NULL)
				req = sstfq->left.queue;
			else {
				if (SNUM_DIFF(sstfq->last_sector,sstfq->right.queue->sectorOffset)
					<SNUM_DIFF(sstfq->last_sector,sstfq->left.qtail->sectorOffset))
				{
					req = sstfq->right.queue;
				}
				else {
					req = sstfq->left.qtail;
				}
			}
		}
	}
	if (req == NULL) {
		RF_ASSERT(QSUM(sstfq) == 0);
	}
	return(req);
}

RF_DiskQueueData_t *rf_ScanPeek(qptr)
  void  *qptr;
{
	RF_DiskQueueData_t *req;
	RF_Sstf_t *scanq;
	int dir;

	scanq = (RF_Sstf_t *)qptr;
	dir = scanq->dir;

	if (scanq->left.queue == NULL) {
		RF_ASSERT(scanq->left.qlen == 0);
		if (scanq->right.queue == NULL) {
			RF_ASSERT(scanq->right.qlen == 0);
			if (scanq->lopri.queue == NULL) {
				RF_ASSERT(scanq->lopri.qlen == 0);
				return(NULL);
			}
			req = closest_to_arm(&scanq->lopri, scanq->last_sector,
				&dir, scanq->allow_reverse);
		}
		else {
			req = scanq->right.queue;
		}
	}
	else if (scanq->right.queue == NULL) {
		RF_ASSERT(scanq->right.qlen == 0);
		RF_ASSERT(scanq->left.queue);
		req = scanq->left.qtail;
	}
	else {
		RF_ASSERT(scanq->right.queue);
		RF_ASSERT(scanq->left.queue);
		if (scanq->dir == DIR_RIGHT) {
			req = scanq->right.queue;
		}
		else {
			req = scanq->left.qtail;
		}
	}
	if (req == NULL) {
		RF_ASSERT(QSUM(scanq) == 0);
	}
	return(req);
}

RF_DiskQueueData_t *rf_CscanPeek(qptr)
  void  *qptr;
{
	RF_DiskQueueData_t *req;
	RF_Sstf_t *cscanq;

	cscanq = (RF_Sstf_t *)qptr;

	RF_ASSERT(cscanq->dir == DIR_RIGHT);
	if (cscanq->right.queue) {
		req = cscanq->right.queue;
	}
	else {
		RF_ASSERT(cscanq->right.qlen == 0);
		if (cscanq->left.queue == NULL) {
			RF_ASSERT(cscanq->left.qlen == 0);
			if (cscanq->lopri.queue == NULL) {
				RF_ASSERT(cscanq->lopri.qlen == 0);
				return(NULL);
			}
			req = closest_to_arm(&cscanq->lopri, cscanq->last_sector,
				&cscanq->dir, cscanq->allow_reverse);
		}
		else {
			/*
			 * There's I/Os to the left of the arm. We'll end
			 * up swinging on back.
			 */
			req = cscanq->left.queue;
		}
	}
	if (req == NULL) {
		RF_ASSERT(QSUM(cscanq) == 0);
	}
	return(req);
}

int rf_SstfPromote(qptr, parityStripeID, which_ru)
  void               *qptr;
  RF_StripeNum_t      parityStripeID;
  RF_ReconUnitNum_t   which_ru;
{
	RF_DiskQueueData_t *r, *next;
	RF_Sstf_t *sstfq;
	int n;

	sstfq = (RF_Sstf_t *)qptr;

	n = 0;
	if (rf_sstfDebug || rf_scanDebug || rf_cscanDebug) {
		int tid;
		rf_get_threadid(tid);
		printf("[%d] promote %ld %d  queues are %d,%d,%d\n",
			parityStripeID, which_ru, sstfq->left.qlen, sstfq->right.qlen,
			sstfq->lopri.qlen);
	}
	for(r=sstfq->lopri.queue;r;r=next) {
		next = r->next;
		if (rf_sstfDebug || rf_scanDebug || rf_cscanDebug) {
			int tid;
			rf_get_threadid(tid);
			printf("[%d] check promote %lx\n", tid, r);
		}
		if ((r->parityStripeID == parityStripeID)
			&& (r->which_ru == which_ru))
		{
			do_dequeue(&sstfq->lopri, r);
			rf_SstfEnqueue(qptr, r, RF_IO_NORMAL_PRIORITY);
			n++;
		}
	}
	if (rf_sstfDebug || rf_scanDebug || rf_cscanDebug) {
		int tid;
		rf_get_threadid(tid);
		printf("[%d] promoted %d matching I/Os queues are %d,%d,%d\n",
			tid, n, sstfq->left.qlen, sstfq->right.qlen, sstfq->lopri.qlen);
	}
	return(n);
}