Anticipatory I/Oスケジューラ の続き。

Elevatorとのインタフェース

Elavatorから呼び出されるAnticipatory I/Oスケジューラのルーチン群はstruct elevator_type iosched_as に定義されている。

.elevator_merge_fn = as_merge



.elevator_next_req_fn = as_next_request

.elevator_dispatch_fn = as_dispatch_request

if (force) {
    // Anticipationを考慮せずに強制的にDispatch
    return dispatched;
}

if (ad->batch_data_dir == REQ_ASYNC && !reads) {
}

/*
 * 以下の条件のいずれかが成り立つ場合はDispatchしない
 *  ・同期/非同期用のいずれかのFIFOが空
 *  ・Anticipation中
 *  ・Batchの向きが変更中
 */
if (!(reads || writes)
    || ad->antic_status == ANTIC_WAIT_REQ
    || ad->antic_status == ANTIC_WAIT_NEXT
    || ad->changed_batch)
       return 0;

if (!(reads && writes && as_batch_expired(ad))) {
    /*
     * 以下のいずれかの条件が真
     *  ・同期I/O   FIFOが空
     *  ・非同期I/O FIFOが空
     *  ・Batchがまだ動作中
     */

    // Dispatch対象のRequestを取りだし
    arq = ad->next_arq[ad->batch_data_dir];

    if (ad->batch_data_dir == REQ_SYNC &&
        ad->antic_expire) {
        // Batchが同期I/Oの場合
        // Anticipationを行ないI/Oをした方がよいかをチェックする。

        // FIFOがExpireしてたならAnticipationは行なわない。
        // FIFOのRequestをDispatchする。
        if (as_fifo_expired(ad, REQ_SYNC))
            goto fifo_expired;

        // Anticipationを始めた方がよいなら開始
        if (as_can_anticipate(ad, arq)) {
            as_antic_waitreq(ad);
            return 0;
        }
    }

    if (arq) {
        // 同期I/O FIFOにRequestがあって、
        // 非同期I/O FIFOにRequestがなければ
        // BatchのExpireを延ばす
        if (reads && !writes)
            ad->current_batch_expires =
               jiffies + ad->batch_expire[REQ_SYNC];
        goto dispatch_request;
    }
}

/*
 * 以下でBatchの開始/向きの変更を行なう。
 */

if (reads) {
    // Read FIFOにRequestがある

    // Write FIFOにRequestがあり、現在のBatchがReadなら
    // dispatch_writesに飛んで、BatchをWriteに変える。
    if (writes && ad->batch_data_dir == REQ_SYNC)
        goto dispatch_writes;

    // さっきまでのBatchがWriteだったならReadに変更
    if (ad->batch_data_dir == REQ_ASYNC) {
        ad->changed_batch = 1;
    }
    // FIFOからDispatchするRequetを取りだす。
    arq =
list_entry_fifo(ad->fifo_list[ad->batch_data_dir].next);
    :
    goto dispatch_request;
}

if (writes) {
    // Write FIFOにRequestがある
dispatch_writes:
    // さっきまでのBatchがReadだったならWriteに変更
    if (ad->batch_data_dir == REQ_SYNC) {
        ad->changed_batch = 1;
        ad->new_batch = 0;
    }
    :
    // DispatchするRequestを取りだし
    arq = ad->next_arq[ad->batch_data_dir];
    goto dispatch_request;
}

return 0;


dispatch_request:
if (as_fifo_expired(ad, ad->batch_data_dir)) {
fifo_expired:
    // FIFOがExpireしている。
    // FIFOのRequestを優先してDispatchするため
    // FIFOからRequestを取り出し。
}

if (ad->changed_batch) {
    // Batchの向きが変更

    // Dispatch済みのRequestが残っているなら、
    // まだ次のBatchを開始しない。
    if (ad->nr_dispatched)
        return 0;

    // WriteBatchへの変更なら、Batchの終了タイマ設定 (*1)
    if (ad->batch_data_dir == REQ_ASYNC)
        ad->current_batch_expires = jiffies +
               ad->batch_expire[REQ_ASYNC];
    else
        ad->new_batch = 1;
    :
}

// RequestをDispatch
as_move_to_dispatch(ad, arq);

return 1;

(*1) ReadBatchの場合は、最初のRequestをDispatchしてI/Oが完了した時に終了タイマが設定される。new_batchは最初のRequestの完了を待つためのフラグ。

.elevator_add_req_fn = as_add_request

.elevator_completed_req_fn = as_completed_request

.elevator_latter_req_fn = as_latter_request

内部の関連関数

as_antic_waitnext()
as_antic_waitreq()

as_antic_timeout()


as_work_handler()

as_move_to_dispatch()

• Anticipation停止(as_antic_stop())
• ANTIC_OFF状態に遷移
• ad->last_sector[]更新
• ad->io_contextの更新(同期I/OならRequestのio_contextを指し、非同期I/OならNULLにする)
  
• ad->next_arq[]更新
• RequestをFIFO,RBTree,Hashから削除
• elv_dispatch_sort()を呼んでRequestQueue(rq->queuelist)へ移動。
• RequestをAS_RQ_DISPATCHED状態にする

as_completed_request()

as_can_anticipate()

• 最後にDispatchしたRequestが非同期I/O(Write I/O) (*1)
• スケジューラの状態がANTIC_FINISHED状態
• as_can_break_anticipation()が真 (*2)

as_can_break_anticipation()

[関連ページ]
I/Oスケジューラ
Anticipatory I/Oスケジューラ