#include "ftl_config.h"
#include "request_format.h"
#include "request_queue.h"

Include dependency graph for request_allocation.h:

This graph shows which files directly or indirectly include this file:

Data Structures
struct	_REQ_POOL
	The request entries pool for both NVMe and NAND requests. More...

Macros
#define	AVAILABLE_OUNTSTANDING_REQ_COUNT ((USER_DIES)*128)

#define	REQ_SLOT_TAG_NONE 0xffff

#define	REQ_SLOT_TAG_FAIL 0xffff

#define	REQ_ENTRY(iEntry) (&reqPoolPtr->reqPool[(iEntry)])
	Get the request entry by entry index. More...

#define	REQ_BUF(iEntry) (REQ_ENTRY((iEntry))->dataBufInfo.entry)

#define	REQ_LSA(iEntry) (REQ_ENTRY((iEntry))->logicalSliceAddr)

#define	REQ_VSA(iEntry) (REQ_ENTRY((iEntry))->nandInfo.virtualSliceAddr)

#define	REQ_CODE_IS(idx, code) (REQ_ENTRY((idx))->reqCode == (code))
	Check the request code of the given request pool entry index. More...

#define	REQ_TYPE_IS(idx, type) (REQ_ENTRY((idx))->reqType == (type))
	Check the request type of the given request pool entry index. More...

#define	REQ_QUEUE_TYPE_IS(idx, qType) (REQ_ENTRY((idx))->reqQueueType == (qType))
	Check the request queue type of the given request pool entry index. More...

Typedefs
typedef struct _REQ_POOL	REQ_POOL
	The request entries pool for both NVMe and NAND requests. More...

typedef struct _REQ_POOL *	P_REQ_POOL

Functions
void	InitReqPool ()
	Initialize the request pool and the request queues. More...

void	PutToFreeReqQ (unsigned int reqSlotTag)
	Add the given request to the free request queue. More...

unsigned int	GetFromFreeReqQ ()
	Get a free request from the free request queue. More...

void	PutToSliceReqQ (unsigned int reqSlotTag)
	Add the given request to the slice request queue. More...

unsigned int	GetFromSliceReqQ ()
	Get a slice request from the slice request queue. More...

void	PutToBlockedByBufDepReqQ (unsigned int reqSlotTag)
	Add the given request to `blockedByBufDepReqQ`. More...

void	SelectiveGetFromBlockedByBufDepReqQ (unsigned int reqSlotTag)
	Remove the given request from the `blockedByBufDepReqQ`. More...

void	PutToBlockedByRowAddrDepReqQ (unsigned int reqSlotTag, unsigned int chNo, unsigned int wayNo)
	Add the given request to `blockedByRowAddrDepReqQ`. More...

void	SelectiveGetFromBlockedByRowAddrDepReqQ (unsigned int reqSlotTag, unsigned int chNo, unsigned int wayNo)
	Remove the given request from the `blockedByRowAddrDepReqQ`. More...

void	PutToNvmeDmaReqQ (unsigned int reqSlotTag)
	Add the given request to the NVMe DMA request queue and update its status. More...

void	SelectiveGetFromNvmeDmaReqQ (unsigned int regSlotTag)
	Move the specified entry from the `nvmeDmaReqQ` to the `freeReqQ`. More...

void	PutToNandReqQ (unsigned int reqSlotTag, unsigned chNo, unsigned wayNo)
	Add the given request to `nandReqQ` of the specified die. More...

void	GetFromNandReqQ (unsigned int chNo, unsigned int wayNo, unsigned int reqStatus, unsigned int reqCode)
	Move the head request of the specified `nandReqQ` queue to `freeReqQ`. More...

Macro Definition Documentation

◆ AVAILABLE_OUNTSTANDING_REQ_COUNT

#define AVAILABLE_OUNTSTANDING_REQ_COUNT ((USER_DIES)*128)

Todo:: why 128?

Warning: typo OUNTSTANDING -> OUTSTANDING

Definition at line 57 of file request_allocation.h.

◆ REQ_BUF

#define REQ_BUF ( iEntry ) (REQ_ENTRY((iEntry))->dataBufInfo.entry)

Definition at line 119 of file request_allocation.h.

◆ REQ_CODE_IS

#define REQ_CODE_IS	(	idx,
		code
	)	(REQ_ENTRY((idx))->reqCode == (code))

Check the request code of the given request pool entry index.

Parameters

idx	the request pool entry index of the request to be checked
code	the supposed request code of this request

Returns: bool true if reqType == type, otherwise false

Definition at line 130 of file request_allocation.h.

◆ REQ_ENTRY

#define REQ_ENTRY ( iEntry ) (&reqPoolPtr->reqPool[(iEntry)])

Get the request entry by entry index.

Parameters

index Index of request pool entry.

Returns: The address of request pool entry.

Definition at line 118 of file request_allocation.h.

◆ REQ_LSA

#define REQ_LSA ( iEntry ) (REQ_ENTRY((iEntry))->logicalSliceAddr)

Definition at line 120 of file request_allocation.h.

◆ REQ_QUEUE_TYPE_IS

#define REQ_QUEUE_TYPE_IS	(	idx,
		qType
	)	(REQ_ENTRY((idx))->reqQueueType == (qType))

Check the request queue type of the given request pool entry index.

Parameters

idx	the request pool entry index of the request to be checked
qType	the supposed queue type of this request

Returns: bool true if reqType == type, otherwise false

Definition at line 148 of file request_allocation.h.

◆ REQ_SLOT_TAG_FAIL

#define REQ_SLOT_TAG_FAIL 0xffff

Definition at line 60 of file request_allocation.h.

◆ REQ_SLOT_TAG_NONE

#define REQ_SLOT_TAG_NONE 0xffff

Definition at line 59 of file request_allocation.h.

◆ REQ_TYPE_IS

#define REQ_TYPE_IS	(	idx,
		type
	)	(REQ_ENTRY((idx))->reqType == (type))

Check the request type of the given request pool entry index.

Parameters

idx	the request pool entry index of the request to be checked
type	the supposed type of this request

Returns: bool true if reqType == type, otherwise false

Definition at line 139 of file request_allocation.h.

◆ REQ_VSA

#define REQ_VSA ( iEntry ) (REQ_ENTRY((iEntry))->nandInfo.virtualSliceAddr)

Definition at line 121 of file request_allocation.h.

Typedef Documentation

◆ P_REQ_POOL

typedef struct _REQ_POOL * P_REQ_POOL

◆ REQ_POOL

typedef struct _REQ_POOL REQ_POOL

The request entries pool for both NVMe and NAND requests.

A 1D fixed-sized array used for managing the request info and relation between requests. Each entry in the pool is represented in the structure SSD_REQ_FORMAT.

Unlike the schematic in the paper, this queue is shared by both host and flash operations, so the structure of SSD_REQ_FORMAT contains some members for distinguishing which type is the request.

Function Documentation

◆ GetFromFreeReqQ()

unsigned int GetFromFreeReqQ ( )

Get a free request from the free request queue.

Try to get the first entry (FIFO) from the free queue. If the freeReqQ is empty, use the function SyncAvailFreeReq() to release some requests and recycle the request pool entries occupied by them.

Returns: unsigned int the request pool entry index of the free request queue entry

Definition at line 172 of file request_allocation.c.

{
    unsigned int reqSlotTag;
 
    reqSlotTag = freeReqQ.headReq;
 
    // try to release some request entries by doing scheduling
    if (reqSlotTag == REQ_SLOT_TAG_NONE)
    {
        SyncAvailFreeReq();
        reqSlotTag = freeReqQ.headReq;
    }
 
    // if the free queue becomes empty, don't forget to update its tail pointer
    if (reqPoolPtr->reqPool[reqSlotTag].nextReq != REQ_SLOT_TAG_NONE)
    {
        freeReqQ.headReq = reqPoolPtr->reqPool[reqSlotTag].nextReq;
        reqPoolPtr->reqPool[reqPoolPtr->reqPool[reqSlotTag].nextReq].prevReq = REQ_SLOT_TAG_NONE;
    }
    else
    {
        freeReqQ.headReq = REQ_SLOT_TAG_NONE;
        freeReqQ.tailReq = REQ_SLOT_TAG_NONE;
    }
 
    reqPoolPtr->reqPool[reqSlotTag].reqQueueType = REQ_QUEUE_TYPE_NONE;
    freeReqQ.reqCnt--;
 
    return reqSlotTag;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetFromNandReqQ()

void GetFromNandReqQ	(	unsigned int	chNo,
		unsigned int	wayNo,
		unsigned int	reqStatus,
		unsigned int	reqCode
	)

Move the head request of the specified nandReqQ queue to freeReqQ.

Similar to GetFromSliceReqQ() and SelectiveGetFromNvmeDmaReqQ().

Warning: currently just simply choose and remove the head request; reqStatus and reqCode not used

Parameters

chNo	the target channel
wayNo	the target way
reqStatus	the status of the previous request executed on the specified die.
reqCode	the command code of the request attempt to execute on the specified die.

Definition at line 548 of file request_allocation.c.

{
    unsigned int reqSlotTag;
 
    reqSlotTag = nandReqQ[chNo][wayNo].headReq;
    if (reqSlotTag == REQ_SLOT_TAG_NONE)
        assert(!"[WARNING] there is no request in Nand-req-queue[WARNING]");
 
    if (reqPoolPtr->reqPool[reqSlotTag].nextReq != REQ_SLOT_TAG_NONE)
    {
        nandReqQ[chNo][wayNo].headReq = reqPoolPtr->reqPool[reqSlotTag].nextReq;
        reqPoolPtr->reqPool[reqPoolPtr->reqPool[reqSlotTag].nextReq].prevReq = REQ_SLOT_TAG_NONE;
    }
    else
    {
        nandReqQ[chNo][wayNo].headReq = REQ_SLOT_TAG_NONE;
        nandReqQ[chNo][wayNo].tailReq = REQ_SLOT_TAG_NONE;
    }
 
    reqPoolPtr->reqPool[reqSlotTag].reqQueueType = REQ_QUEUE_TYPE_NONE;
    nandReqQ[chNo][wayNo].reqCnt--;
    notCompletedNandReqCnt--;
 
    PutToFreeReqQ(reqSlotTag);
    ReleaseBlockedByBufDepReq(reqSlotTag);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetFromSliceReqQ()

unsigned int GetFromSliceReqQ ( )

Get a slice request from the slice request queue.

Try to pop the first request of the slice request queue.

Note: fail if the request queue is empty.

Returns: unsigned int the entry index of chosen slice request, or REQ_SLOT_TAG_FAIL if the slice request queue is empty.

Definition at line 241 of file request_allocation.c.

{
    unsigned int reqSlotTag;
 
    reqSlotTag = sliceReqQ.headReq;
 
    if (reqSlotTag == REQ_SLOT_TAG_NONE)
        return REQ_SLOT_TAG_FAIL;
 
    if (reqPoolPtr->reqPool[reqSlotTag].nextReq != REQ_SLOT_TAG_NONE)
    {
        sliceReqQ.headReq = reqPoolPtr->reqPool[reqSlotTag].nextReq;
        reqPoolPtr->reqPool[reqPoolPtr->reqPool[reqSlotTag].nextReq].prevReq = REQ_SLOT_TAG_NONE;
    }
    else
    {
        sliceReqQ.headReq = REQ_SLOT_TAG_NONE;
        sliceReqQ.tailReq = REQ_SLOT_TAG_NONE;
    }
 
    reqPoolPtr->reqPool[reqSlotTag].reqQueueType = REQ_QUEUE_TYPE_NONE;
    sliceReqQ.reqCnt--;
 
    return reqSlotTag;
}

Here is the caller graph for this function:

◆ InitReqPool()

void InitReqPool ( )

Initialize the request pool and the request queues.

At the beginning, all the requests are stored in the freeReqQ, therefore the size of freeReqQ should equal to the size of request pool, and the others request queue will be initialized to be empty.

After all the queues are initialized, we next have to initialize the request pool:

all the entries should belongs to freeReqQ by default
all the entries should be connected in serial order
no request exists at the beginning, therefore:
- the number of not completed NAND request is zero
- the number of blocking requests is zero
- both prevBlockingReq and nextBlockingReq should be NONE

Definition at line 77 of file request_allocation.c.

{
    int chNo, wayNo, reqSlotTag;
 
    reqPoolPtr = (P_REQ_POOL)REQ_POOL_ADDR; // revise address
 
    freeReqQ.headReq = 0;
    freeReqQ.tailReq = AVAILABLE_OUNTSTANDING_REQ_COUNT - 1;
 
    sliceReqQ.headReq = REQ_SLOT_TAG_NONE;
    sliceReqQ.tailReq = REQ_SLOT_TAG_NONE;
    sliceReqQ.reqCnt  = 0;
 
    blockedByBufDepReqQ.headReq = REQ_SLOT_TAG_NONE;
    blockedByBufDepReqQ.tailReq = REQ_SLOT_TAG_NONE;
    blockedByBufDepReqQ.reqCnt  = 0;
 
    nvmeDmaReqQ.headReq = REQ_SLOT_TAG_NONE;
    nvmeDmaReqQ.tailReq = REQ_SLOT_TAG_NONE;
    nvmeDmaReqQ.reqCnt  = 0;
 
    for (chNo = 0; chNo < USER_CHANNELS; chNo++)
        for (wayNo = 0; wayNo < USER_WAYS; wayNo++)
        {
            blockedByRowAddrDepReqQ[chNo][wayNo].headReq = REQ_SLOT_TAG_NONE;
            blockedByRowAddrDepReqQ[chNo][wayNo].tailReq = REQ_SLOT_TAG_NONE;
            blockedByRowAddrDepReqQ[chNo][wayNo].reqCnt  = 0;
 
            nandReqQ[chNo][wayNo].headReq = REQ_SLOT_TAG_NONE;
            nandReqQ[chNo][wayNo].tailReq = REQ_SLOT_TAG_NONE;
            nandReqQ[chNo][wayNo].reqCnt  = 0;
        }
 
    for (reqSlotTag = 0; reqSlotTag < AVAILABLE_OUNTSTANDING_REQ_COUNT; reqSlotTag++)
    {
        reqPoolPtr->reqPool[reqSlotTag].reqQueueType    = REQ_QUEUE_TYPE_FREE;
        reqPoolPtr->reqPool[reqSlotTag].prevBlockingReq = REQ_SLOT_TAG_NONE;
        reqPoolPtr->reqPool[reqSlotTag].nextBlockingReq = REQ_SLOT_TAG_NONE;
        reqPoolPtr->reqPool[reqSlotTag].prevReq         = reqSlotTag - 1;
        reqPoolPtr->reqPool[reqSlotTag].nextReq         = reqSlotTag + 1;
    }
 
    reqPoolPtr->reqPool[0].prevReq                                    = REQ_SLOT_TAG_NONE;
    reqPoolPtr->reqPool[AVAILABLE_OUNTSTANDING_REQ_COUNT - 1].nextReq = REQ_SLOT_TAG_NONE;
    freeReqQ.reqCnt = AVAILABLE_OUNTSTANDING_REQ_COUNT; // TODO: move this up ?
 
    notCompletedNandReqCnt = 0;
    blockedReqCnt          = 0;
}

Here is the caller graph for this function:

◆ PutToBlockedByBufDepReqQ()

void PutToBlockedByBufDepReqQ ( unsigned int reqSlotTag )

Add the given request to blockedByBufDepReqQ.

Similar to PutToFreeReqQ().

Note: the request blocked by buffer dependency is also a blocked request, therefore the blockedReqCnt should also be increased.

Parameters

reqSlotTag the request pool entry index of the request to be added

Definition at line 277 of file request_allocation.c.

{
    if (blockedByBufDepReqQ.tailReq != REQ_SLOT_TAG_NONE)
    {
        reqPoolPtr->reqPool[reqSlotTag].prevReq                  = blockedByBufDepReqQ.tailReq;
        reqPoolPtr->reqPool[reqSlotTag].nextReq                  = REQ_SLOT_TAG_NONE;
        reqPoolPtr->reqPool[blockedByBufDepReqQ.tailReq].nextReq = reqSlotTag;
        blockedByBufDepReqQ.tailReq                              = reqSlotTag;
    }
    else
    {
        reqPoolPtr->reqPool[reqSlotTag].prevReq = REQ_SLOT_TAG_NONE;
        reqPoolPtr->reqPool[reqSlotTag].nextReq = REQ_SLOT_TAG_NONE;
        blockedByBufDepReqQ.headReq             = reqSlotTag;
        blockedByBufDepReqQ.tailReq             = reqSlotTag;
    }
 
    reqPoolPtr->reqPool[reqSlotTag].reqQueueType = REQ_QUEUE_TYPE_BLOCKED_BY_BUF_DEP;
    blockedByBufDepReqQ.reqCnt++;
    blockedReqCnt++;
}

Here is the caller graph for this function:

◆ PutToBlockedByRowAddrDepReqQ()

void PutToBlockedByRowAddrDepReqQ	(	unsigned int	reqSlotTag,
		unsigned int	chNo,
		unsigned int	wayNo
	)

Add the given request to blockedByRowAddrDepReqQ.

Similar to PutToBlockedByBufDepReqQ().

Note: the request blocked by row address dependency is also a blocked request, the blockedReqCnt thus should also be increased.

Parameters

reqSlotTag	the request pool entry index of the request to be added.
chNo	the channel number of the specified queue.
wayNo	the die number of the specified queue.

Definition at line 357 of file request_allocation.c.

{
    if (blockedByRowAddrDepReqQ[chNo][wayNo].tailReq != REQ_SLOT_TAG_NONE)
    {
        reqPoolPtr->reqPool[reqSlotTag].prevReq = blockedByRowAddrDepReqQ[chNo][wayNo].tailReq;
        reqPoolPtr->reqPool[reqSlotTag].nextReq = REQ_SLOT_TAG_NONE;
        reqPoolPtr->reqPool[blockedByRowAddrDepReqQ[chNo][wayNo].tailReq].nextReq = reqSlotTag;
        blockedByRowAddrDepReqQ[chNo][wayNo].tailReq                              = reqSlotTag;
    }
    else
    {
        reqPoolPtr->reqPool[reqSlotTag].prevReq      = REQ_SLOT_TAG_NONE;
        reqPoolPtr->reqPool[reqSlotTag].nextReq      = REQ_SLOT_TAG_NONE;
        blockedByRowAddrDepReqQ[chNo][wayNo].headReq = reqSlotTag;
        blockedByRowAddrDepReqQ[chNo][wayNo].tailReq = reqSlotTag;
    }
 
    reqPoolPtr->reqPool[reqSlotTag].reqQueueType = REQ_QUEUE_TYPE_BLOCKED_BY_ROW_ADDR_DEP;
    blockedByRowAddrDepReqQ[chNo][wayNo].reqCnt++;
    blockedReqCnt++;
}

Here is the caller graph for this function:

◆ PutToFreeReqQ()

void PutToFreeReqQ ( unsigned int reqSlotTag )

Add the given request to the free request queue.

Insert the given request into the tail of the free queue and update the corresponding field of the given request.

Note: this function will not modify the prevReq of the next request in the original request queue. That is, the prev request entry index of the original next request may still be reqSlotTag.; also, this function will not modify the prevBlockingReq and nextBlockingReq of the original request.

Parameters

reqSlotTag the request pool entry index of the request to be added.

Definition at line 142 of file request_allocation.c.

{
    if (freeReqQ.tailReq != REQ_SLOT_TAG_NONE)
    {
        reqPoolPtr->reqPool[reqSlotTag].prevReq       = freeReqQ.tailReq;
        reqPoolPtr->reqPool[reqSlotTag].nextReq       = REQ_SLOT_TAG_NONE;
        reqPoolPtr->reqPool[freeReqQ.tailReq].nextReq = reqSlotTag;
        freeReqQ.tailReq                              = reqSlotTag;
    }
    else
    {
        reqPoolPtr->reqPool[reqSlotTag].prevReq = REQ_SLOT_TAG_NONE;
        reqPoolPtr->reqPool[reqSlotTag].nextReq = REQ_SLOT_TAG_NONE;
        freeReqQ.headReq                        = reqSlotTag;
        freeReqQ.tailReq                        = reqSlotTag;
    }
 
    reqPoolPtr->reqPool[reqSlotTag].reqQueueType = REQ_QUEUE_TYPE_FREE;
    freeReqQ.reqCnt++;
}

Here is the caller graph for this function:

◆ PutToNandReqQ()

void PutToNandReqQ	(	unsigned int	reqSlotTag,
		unsigned	chNo,
		unsigned	wayNo
	)

Add the given request to nandReqQ of the specified die.

Similar to PutToFreeReqQ().

Note: we should not only increase the size of the specified request queue, but also increase the number of uncompleted nand request.

Parameters

reqSlotTag	the request pool entry index of the request to be added.
chNo	the channel number of the specified queue.
wayNo	the die number of the specified queue.

Definition at line 512 of file request_allocation.c.

{
    if (nandReqQ[chNo][wayNo].tailReq != REQ_SLOT_TAG_NONE)
    {
        reqPoolPtr->reqPool[reqSlotTag].prevReq                    = nandReqQ[chNo][wayNo].tailReq;
        reqPoolPtr->reqPool[reqSlotTag].nextReq                    = REQ_SLOT_TAG_NONE;
        reqPoolPtr->reqPool[nandReqQ[chNo][wayNo].tailReq].nextReq = reqSlotTag;
        nandReqQ[chNo][wayNo].tailReq                              = reqSlotTag;
    }
    else
    {
        reqPoolPtr->reqPool[reqSlotTag].prevReq = REQ_SLOT_TAG_NONE;
        reqPoolPtr->reqPool[reqSlotTag].nextReq = REQ_SLOT_TAG_NONE;
        nandReqQ[chNo][wayNo].headReq           = reqSlotTag;
        nandReqQ[chNo][wayNo].tailReq           = reqSlotTag;
    }
 
    reqPoolPtr->reqPool[reqSlotTag].reqQueueType = REQ_QUEUE_TYPE_NAND;
    nandReqQ[chNo][wayNo].reqCnt++;
    notCompletedNandReqCnt++;
}

Here is the caller graph for this function:

◆ PutToNvmeDmaReqQ()

void PutToNvmeDmaReqQ ( unsigned int reqSlotTag )

Add the given request to the NVMe DMA request queue and update its status.

Similar to PutToFreeReqQ().

Parameters

reqSlotTag the request pool entry index of the request to be added

Definition at line 431 of file request_allocation.c.

{
    if (nvmeDmaReqQ.tailReq != REQ_SLOT_TAG_NONE)
    {
        reqPoolPtr->reqPool[reqSlotTag].prevReq          = nvmeDmaReqQ.tailReq;
        reqPoolPtr->reqPool[reqSlotTag].nextReq          = REQ_SLOT_TAG_NONE;
        reqPoolPtr->reqPool[nvmeDmaReqQ.tailReq].nextReq = reqSlotTag;
        nvmeDmaReqQ.tailReq                              = reqSlotTag;
    }
    else
    {
        reqPoolPtr->reqPool[reqSlotTag].prevReq = REQ_SLOT_TAG_NONE;
        reqPoolPtr->reqPool[reqSlotTag].nextReq = REQ_SLOT_TAG_NONE;
        nvmeDmaReqQ.headReq                     = reqSlotTag;
        nvmeDmaReqQ.tailReq                     = reqSlotTag;
    }
 
    reqPoolPtr->reqPool[reqSlotTag].reqQueueType = REQ_QUEUE_TYPE_NVME_DMA;
    nvmeDmaReqQ.reqCnt++;
}

Here is the caller graph for this function:

◆ PutToSliceReqQ()

void PutToSliceReqQ ( unsigned int reqSlotTag )

Add the given request to the slice request queue.

Similar to PutToFreeReqQ().

Parameters

reqSlotTag the request pool entry index of the request to be added

Definition at line 210 of file request_allocation.c.

{
    if (sliceReqQ.tailReq != REQ_SLOT_TAG_NONE)
    {
        reqPoolPtr->reqPool[reqSlotTag].prevReq        = sliceReqQ.tailReq;
        reqPoolPtr->reqPool[reqSlotTag].nextReq        = REQ_SLOT_TAG_NONE;
        reqPoolPtr->reqPool[sliceReqQ.tailReq].nextReq = reqSlotTag;
        sliceReqQ.tailReq                              = reqSlotTag;
    }
    else
    {
        reqPoolPtr->reqPool[reqSlotTag].prevReq = REQ_SLOT_TAG_NONE;
        reqPoolPtr->reqPool[reqSlotTag].nextReq = REQ_SLOT_TAG_NONE;
        sliceReqQ.headReq                       = reqSlotTag;
        sliceReqQ.tailReq                       = reqSlotTag;
    }
 
    reqPoolPtr->reqPool[reqSlotTag].reqQueueType = REQ_QUEUE_TYPE_SLICE;
    sliceReqQ.reqCnt++;
}

Here is the caller graph for this function:

◆ SelectiveGetFromBlockedByBufDepReqQ()

void SelectiveGetFromBlockedByBufDepReqQ ( unsigned int reqSlotTag )

Remove the given request from the blockedByBufDepReqQ.

Similar to GetFromSliceReqQ(), but the entry to be removed is specified by the param reqSlotTag.

Note: don't forget to decrease blockedReqCnt

Parameters

reqSlotTag the request pool entry index of the request to be removed

Definition at line 309 of file request_allocation.c.

{
    unsigned int prevReq, nextReq;
 
    if (reqSlotTag == REQ_SLOT_TAG_NONE)
        assert(!"[WARNING] Wrong reqSlotTag [WARNING]");
 
    prevReq = reqPoolPtr->reqPool[reqSlotTag].prevReq;
    nextReq = reqPoolPtr->reqPool[reqSlotTag].nextReq;
 
    if ((nextReq != REQ_SLOT_TAG_NONE) && (prevReq != REQ_SLOT_TAG_NONE))
    {
        reqPoolPtr->reqPool[prevReq].nextReq = nextReq;
        reqPoolPtr->reqPool[nextReq].prevReq = prevReq;
    }
    else if ((nextReq == REQ_SLOT_TAG_NONE) && (prevReq != REQ_SLOT_TAG_NONE))
    {
        reqPoolPtr->reqPool[prevReq].nextReq = REQ_SLOT_TAG_NONE;
        blockedByBufDepReqQ.tailReq          = prevReq;
    }
    else if ((nextReq != REQ_SLOT_TAG_NONE) && (prevReq == REQ_SLOT_TAG_NONE))
    {
        reqPoolPtr->reqPool[nextReq].prevReq = REQ_SLOT_TAG_NONE;
        blockedByBufDepReqQ.headReq          = nextReq;
    }
    else
    {
        blockedByBufDepReqQ.headReq = REQ_SLOT_TAG_NONE;
        blockedByBufDepReqQ.tailReq = REQ_SLOT_TAG_NONE;
    }
 
    reqPoolPtr->reqPool[reqSlotTag].reqQueueType = REQ_QUEUE_TYPE_NONE;
    blockedByBufDepReqQ.reqCnt--;
    blockedReqCnt--;
}

Here is the caller graph for this function:

◆ SelectiveGetFromBlockedByRowAddrDepReqQ()

void SelectiveGetFromBlockedByRowAddrDepReqQ	(	unsigned int	reqSlotTag,
		unsigned int	chNo,
		unsigned int	wayNo
	)

Remove the given request from the blockedByRowAddrDepReqQ.

Parameters

reqSlotTag	the request pool entry index of the request to be removed.
chNo	the channel number of the specified queue.
wayNo	the die number of the specified queue.

Definition at line 388 of file request_allocation.c.

{
    unsigned int prevReq, nextReq;
 
    if (reqSlotTag == REQ_SLOT_TAG_NONE)
        assert(!"[WARNING] Wrong reqSlotTag [WARNING]");
 
    prevReq = reqPoolPtr->reqPool[reqSlotTag].prevReq;
    nextReq = reqPoolPtr->reqPool[reqSlotTag].nextReq;
 
    if ((nextReq != REQ_SLOT_TAG_NONE) && (prevReq != REQ_SLOT_TAG_NONE))
    {
        reqPoolPtr->reqPool[prevReq].nextReq = nextReq;
        reqPoolPtr->reqPool[nextReq].prevReq = prevReq;
    }
    else if ((nextReq == REQ_SLOT_TAG_NONE) && (prevReq != REQ_SLOT_TAG_NONE))
    {
        reqPoolPtr->reqPool[prevReq].nextReq         = REQ_SLOT_TAG_NONE;
        blockedByRowAddrDepReqQ[chNo][wayNo].tailReq = prevReq;
    }
    else if ((nextReq != REQ_SLOT_TAG_NONE) && (prevReq == REQ_SLOT_TAG_NONE))
    {
        reqPoolPtr->reqPool[nextReq].prevReq         = REQ_SLOT_TAG_NONE;
        blockedByRowAddrDepReqQ[chNo][wayNo].headReq = nextReq;
    }
    else
    {
        blockedByRowAddrDepReqQ[chNo][wayNo].headReq = REQ_SLOT_TAG_NONE;
        blockedByRowAddrDepReqQ[chNo][wayNo].tailReq = REQ_SLOT_TAG_NONE;
    }
 
    reqPoolPtr->reqPool[reqSlotTag].reqQueueType = REQ_QUEUE_TYPE_NONE;
    blockedByRowAddrDepReqQ[chNo][wayNo].reqCnt--;
    blockedReqCnt--;
}

Here is the caller graph for this function:

◆ SelectiveGetFromNvmeDmaReqQ()

void SelectiveGetFromNvmeDmaReqQ ( unsigned int reqSlotTag )

Move the specified entry from the nvmeDmaReqQ to the freeReqQ.

Remove the given request entry from the NVMe DMA request queue, and then insert into the free request queue.

Note: the function PutToFreeReqQ() and its friends won't modify the prevBlockingReq and the nextBlockingReq of the specified request entry, therefore after request being added to free request queue, we should also try to remove the specified request from the blocking request by calling the function ReleaseBlockedByBufDepReq(). // FIXME

Parameters

reqSlotTag the request pool entry index of the request to be removed

Definition at line 465 of file request_allocation.c.

{
    unsigned int prevReq, nextReq;
 
    prevReq = reqPoolPtr->reqPool[reqSlotTag].prevReq;
    nextReq = reqPoolPtr->reqPool[reqSlotTag].nextReq;
 
    if ((nextReq != REQ_SLOT_TAG_NONE) && (prevReq != REQ_SLOT_TAG_NONE))
    {
        reqPoolPtr->reqPool[prevReq].nextReq = nextReq;
        reqPoolPtr->reqPool[nextReq].prevReq = prevReq;
    }
    else if ((nextReq == REQ_SLOT_TAG_NONE) && (prevReq != REQ_SLOT_TAG_NONE))
    {
        reqPoolPtr->reqPool[prevReq].nextReq = REQ_SLOT_TAG_NONE;
        nvmeDmaReqQ.tailReq                  = prevReq;
    }
    else if ((nextReq != REQ_SLOT_TAG_NONE) && (prevReq == REQ_SLOT_TAG_NONE))
    {
        reqPoolPtr->reqPool[nextReq].prevReq = REQ_SLOT_TAG_NONE;
        nvmeDmaReqQ.headReq                  = nextReq;
    }
    else
    {
        nvmeDmaReqQ.headReq = REQ_SLOT_TAG_NONE;
        nvmeDmaReqQ.tailReq = REQ_SLOT_TAG_NONE;
    }
 
    reqPoolPtr->reqPool[reqSlotTag].reqQueueType = REQ_QUEUE_TYPE_NONE;
    nvmeDmaReqQ.reqCnt--;
 
    PutToFreeReqQ(reqSlotTag);
    ReleaseBlockedByBufDepReq(reqSlotTag); // release the request from blocking request if needed
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

◆ blockedByBufDepReqQ

BLOCKED_BY_BUFFER_DEPENDENCY_REQUEST_QUEUE blockedByBufDepReqQ

extern

Definition at line 53 of file request_allocation.c.

◆ blockedByRowAddrDepReqQ

BLOCKED_BY_ROW_ADDR_DEPENDENCY_REQUEST_QUEUE blockedByRowAddrDepReqQ[USER_CHANNELS][USER_WAYS]

extern

Definition at line 54 of file request_allocation.c.

◆ blockedReqCnt

unsigned int blockedReqCnt

extern

Definition at line 59 of file request_allocation.c.

◆ freeReqQ

FREE_REQUEST_QUEUE freeReqQ

extern

Definition at line 51 of file request_allocation.c.

◆ nandReqQ

NAND_REQUEST_QUEUE nandReqQ[USER_CHANNELS][USER_WAYS]

extern

Definition at line 56 of file request_allocation.c.

◆ notCompletedNandReqCnt

unsigned int notCompletedNandReqCnt

extern

Definition at line 58 of file request_allocation.c.

◆ nvmeDmaReqQ

NVME_DMA_REQUEST_QUEUE nvmeDmaReqQ

extern

Definition at line 55 of file request_allocation.c.

◆ reqPoolPtr

P_REQ_POOL reqPoolPtr

extern

Definition at line 50 of file request_allocation.c.

◆ sliceReqQ

SLICE_REQUEST_QUEUE sliceReqQ

extern

Definition at line 52 of file request_allocation.c.

Variables
P_REQ_POOL	reqPoolPtr

FREE_REQUEST_QUEUE	freeReqQ

SLICE_REQUEST_QUEUE	sliceReqQ

BLOCKED_BY_BUFFER_DEPENDENCY_REQUEST_QUEUE	blockedByBufDepReqQ

BLOCKED_BY_ROW_ADDR_DEPENDENCY_REQUEST_QUEUE	blockedByRowAddrDepReqQ [USER_CHANNELS][USER_WAYS]

NVME_DMA_REQUEST_QUEUE	nvmeDmaReqQ

NAND_REQUEST_QUEUE	nandReqQ [USER_CHANNELS][USER_WAYS]

unsigned int	notCompletedNandReqCnt

unsigned int	blockedReqCnt

Data Structures

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

◆ AVAILABLE_OUNTSTANDING_REQ_COUNT

◆ REQ_BUF

◆ REQ_CODE_IS

◆ REQ_ENTRY

◆ REQ_LSA

◆ REQ_QUEUE_TYPE_IS

◆ REQ_SLOT_TAG_FAIL

◆ REQ_SLOT_TAG_NONE

◆ REQ_TYPE_IS

◆ REQ_VSA

Typedef Documentation

◆ P_REQ_POOL

◆ REQ_POOL

Function Documentation

◆ GetFromFreeReqQ()

◆ GetFromNandReqQ()

◆ GetFromSliceReqQ()

◆ InitReqPool()

◆ PutToBlockedByBufDepReqQ()

◆ PutToBlockedByRowAddrDepReqQ()

◆ PutToFreeReqQ()

◆ PutToNandReqQ()

◆ PutToNvmeDmaReqQ()

◆ PutToSliceReqQ()

◆ SelectiveGetFromBlockedByBufDepReqQ()

◆ SelectiveGetFromBlockedByRowAddrDepReqQ()

◆ SelectiveGetFromNvmeDmaReqQ()

Variable Documentation

◆ blockedByBufDepReqQ

◆ blockedByRowAddrDepReqQ

◆ blockedReqCnt

◆ freeReqQ

◆ nandReqQ

◆ notCompletedNandReqCnt

◆ nvmeDmaReqQ

◆ reqPoolPtr

◆ sliceReqQ