mirrors/qemu
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

aio: rename AIOPool to AIOCBInfo

Browse Source 
Now that AIOPool no longer keeps a freelist, it isn't really a "pool"
anymore.  Rename it to AIOCBInfo and make it const since it no longer
needs to be modified.

Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
This commit is contained in:
Stefan Hajnoczi 2012-10-31 16:34:37 +01:00 committed by Kevin Wolf
parent d37c975fb1
commit d7331bed11
15 changed files with 46 additions and 46 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
block.c
View File

@ -3521,7 +3521,7 @@ int bdrv_aio_multiwrite(BlockDriverState *bs, BlockRequest *reqs, int num_reqs)
void bdrv_aio_cancel(BlockDriverAIOCB *acb) void bdrv_aio_cancel(BlockDriverAIOCB *acb)
{ {
acb->pool->cancel(acb); acb->aiocb_info->cancel(acb);
} }
/* block I/O throttling */ /* block I/O throttling */
@ -3711,7 +3711,7 @@ static void bdrv_aio_cancel_em(BlockDriverAIOCB *blockacb)
qemu_aio_release(acb); qemu_aio_release(acb);
} }
static AIOPool bdrv_em_aio_pool = { static const AIOCBInfo bdrv_em_aiocb_info = {
.aiocb_size = sizeof(BlockDriverAIOCBSync), .aiocb_size = sizeof(BlockDriverAIOCBSync),
.cancel = bdrv_aio_cancel_em, .cancel = bdrv_aio_cancel_em,
}; };
@ -3740,7 +3740,7 @@ static BlockDriverAIOCB *bdrv_aio_rw_vector(BlockDriverState *bs,
{ {
BlockDriverAIOCBSync *acb; BlockDriverAIOCBSync *acb;
acb = qemu_aio_get(&bdrv_em_aio_pool, bs, cb, opaque); acb = qemu_aio_get(&bdrv_em_aiocb_info, bs, cb, opaque);
acb->is_write = is_write; acb->is_write = is_write;
acb->qiov = qiov; acb->qiov = qiov;
acb->bounce = qemu_blockalign(bs, qiov->size); acb->bounce = qemu_blockalign(bs, qiov->size);
@ -3785,7 +3785,7 @@ static void bdrv_aio_co_cancel_em(BlockDriverAIOCB *blockacb)
qemu_aio_flush(); qemu_aio_flush();
} }
static AIOPool bdrv_em_co_aio_pool = { static const AIOCBInfo bdrv_em_co_aiocb_info = {
.aiocb_size = sizeof(BlockDriverAIOCBCoroutine), .aiocb_size = sizeof(BlockDriverAIOCBCoroutine),
.cancel = bdrv_aio_co_cancel_em, .cancel = bdrv_aio_co_cancel_em,
}; };
@ -3828,7 +3828,7 @@ static BlockDriverAIOCB *bdrv_co_aio_rw_vector(BlockDriverState *bs,
Coroutine *co; Coroutine *co;
BlockDriverAIOCBCoroutine *acb; BlockDriverAIOCBCoroutine *acb;
acb = qemu_aio_get(&bdrv_em_co_aio_pool, bs, cb, opaque); acb = qemu_aio_get(&bdrv_em_co_aiocb_info, bs, cb, opaque);
acb->req.sector = sector_num; acb->req.sector = sector_num;
acb->req.nb_sectors = nb_sectors; acb->req.nb_sectors = nb_sectors;
acb->req.qiov = qiov; acb->req.qiov = qiov;
@ -3858,7 +3858,7 @@ BlockDriverAIOCB *bdrv_aio_flush(BlockDriverState *bs,
Coroutine *co; Coroutine *co;
BlockDriverAIOCBCoroutine *acb; BlockDriverAIOCBCoroutine *acb;
acb = qemu_aio_get(&bdrv_em_co_aio_pool, bs, cb, opaque); acb = qemu_aio_get(&bdrv_em_co_aiocb_info, bs, cb, opaque);
co = qemu_coroutine_create(bdrv_aio_flush_co_entry); co = qemu_coroutine_create(bdrv_aio_flush_co_entry);
qemu_coroutine_enter(co, acb); qemu_coroutine_enter(co, acb);
@ -3884,7 +3884,7 @@ BlockDriverAIOCB *bdrv_aio_discard(BlockDriverState *bs,
trace_bdrv_aio_discard(bs, sector_num, nb_sectors, opaque); trace_bdrv_aio_discard(bs, sector_num, nb_sectors, opaque);
acb = qemu_aio_get(&bdrv_em_co_aio_pool, bs, cb, opaque); acb = qemu_aio_get(&bdrv_em_co_aiocb_info, bs, cb, opaque);
acb->req.sector = sector_num; acb->req.sector = sector_num;
acb->req.nb_sectors = nb_sectors; acb->req.nb_sectors = nb_sectors;
co = qemu_coroutine_create(bdrv_aio_discard_co_entry); co = qemu_coroutine_create(bdrv_aio_discard_co_entry);
@ -3904,13 +3904,13 @@ void bdrv_init_with_whitelist(void)
bdrv_init(); bdrv_init();
} }
void *qemu_aio_get(AIOPool *pool, BlockDriverState *bs, void *qemu_aio_get(const AIOCBInfo *aiocb_info, BlockDriverState *bs,
BlockDriverCompletionFunc *cb, void *opaque) BlockDriverCompletionFunc *cb, void *opaque)
{ {
BlockDriverAIOCB *acb; BlockDriverAIOCB *acb;
acb = g_slice_alloc(pool->aiocb_size); acb = g_slice_alloc(aiocb_info->aiocb_size);
acb->pool = pool; acb->aiocb_info = aiocb_info;
acb->bs = bs; acb->bs = bs;
acb->cb = cb; acb->cb = cb;
acb->opaque = opaque; acb->opaque = opaque;
@ -3920,7 +3920,7 @@ void *qemu_aio_get(AIOPool *pool, BlockDriverState *bs,
void qemu_aio_release(void *p) void qemu_aio_release(void *p)
{ {
BlockDriverAIOCB *acb = p; BlockDriverAIOCB *acb = p;
g_slice_free1(acb->pool->aiocb_size, acb); g_slice_free1(acb->aiocb_info->aiocb_size, acb);
} }
/**************************************************************/ /**************************************************************/

4
block/blkdebug.c
View File

@ -41,7 +41,7 @@ typedef struct BlkdebugAIOCB {
static void blkdebug_aio_cancel(BlockDriverAIOCB *blockacb); static void blkdebug_aio_cancel(BlockDriverAIOCB *blockacb);
static AIOPool blkdebug_aio_pool = { static const AIOCBInfo blkdebug_aiocb_info = {
.aiocb_size = sizeof(BlkdebugAIOCB), .aiocb_size = sizeof(BlkdebugAIOCB),
.cancel = blkdebug_aio_cancel, .cancel = blkdebug_aio_cancel,
}; };
@ -335,7 +335,7 @@ static BlockDriverAIOCB *inject_error(BlockDriverState *bs,
return NULL; return NULL;
} }
acb = qemu_aio_get(&blkdebug_aio_pool, bs, cb, opaque); acb = qemu_aio_get(&blkdebug_aiocb_info, bs, cb, opaque);
acb->ret = -error; acb->ret = -error;
bh = qemu_bh_new(error_callback_bh, acb); bh = qemu_bh_new(error_callback_bh, acb);

4
block/blkverify.c
View File

@ -48,7 +48,7 @@ static void blkverify_aio_cancel(BlockDriverAIOCB *blockacb)
} }
} }
static AIOPool blkverify_aio_pool = { static const AIOCBInfo blkverify_aiocb_info = {
.aiocb_size = sizeof(BlkverifyAIOCB), .aiocb_size = sizeof(BlkverifyAIOCB),
.cancel = blkverify_aio_cancel, .cancel = blkverify_aio_cancel,
}; };
@ -233,7 +233,7 @@ static BlkverifyAIOCB *blkverify_aio_get(BlockDriverState *bs, bool is_write,
BlockDriverCompletionFunc *cb, BlockDriverCompletionFunc *cb,
void *opaque) void *opaque)
{ {
BlkverifyAIOCB *acb = qemu_aio_get(&blkverify_aio_pool, bs, cb, opaque); BlkverifyAIOCB *acb = qemu_aio_get(&blkverify_aiocb_info, bs, cb, opaque);
acb->bh = NULL; acb->bh = NULL;
acb->is_write = is_write; acb->is_write = is_write;

4
block/curl.c
View File

@ -438,7 +438,7 @@ static void curl_aio_cancel(BlockDriverAIOCB *blockacb)
// Do we have to implement canceling? Seems to work without... // Do we have to implement canceling? Seems to work without...
} }
static AIOPool curl_aio_pool = { static const AIOCBInfo curl_aiocb_info = {
.aiocb_size = sizeof(CURLAIOCB), .aiocb_size = sizeof(CURLAIOCB),
.cancel = curl_aio_cancel, .cancel = curl_aio_cancel,
}; };
@ -505,7 +505,7 @@ static BlockDriverAIOCB *curl_aio_readv(BlockDriverState *bs,
{ {
CURLAIOCB *acb; CURLAIOCB *acb;
acb = qemu_aio_get(&curl_aio_pool, bs, cb, opaque); acb = qemu_aio_get(&curl_aiocb_info, bs, cb, opaque);
acb->qiov = qiov; acb->qiov = qiov;
acb->sector_num = sector_num; acb->sector_num = sector_num;

6
block/gluster.c
View File

@ -388,7 +388,7 @@ static void qemu_gluster_aio_cancel(BlockDriverAIOCB *blockacb)
} }
} }
static AIOPool gluster_aio_pool = { static const AIOCBInfo gluster_aiocb_info = {
.aiocb_size = sizeof(GlusterAIOCB), .aiocb_size = sizeof(GlusterAIOCB),
.cancel = qemu_gluster_aio_cancel, .cancel = qemu_gluster_aio_cancel,
}; };
@ -439,7 +439,7 @@ static BlockDriverAIOCB *qemu_gluster_aio_rw(BlockDriverState *bs,
size = nb_sectors * BDRV_SECTOR_SIZE; size = nb_sectors * BDRV_SECTOR_SIZE;
s->qemu_aio_count++; s->qemu_aio_count++;
acb = qemu_aio_get(&gluster_aio_pool, bs, cb, opaque); acb = qemu_aio_get(&gluster_aiocb_info, bs, cb, opaque);
acb->size = size; acb->size = size;
acb->ret = 0; acb->ret = 0;
acb->finished = NULL; acb->finished = NULL;
@ -484,7 +484,7 @@ static BlockDriverAIOCB *qemu_gluster_aio_flush(BlockDriverState *bs,
GlusterAIOCB *acb; GlusterAIOCB *acb;
BDRVGlusterState *s = bs->opaque; BDRVGlusterState *s = bs->opaque;
acb = qemu_aio_get(&gluster_aio_pool, bs, cb, opaque); acb = qemu_aio_get(&gluster_aiocb_info, bs, cb, opaque);
acb->size = 0; acb->size = 0;
acb->ret = 0; acb->ret = 0;
acb->finished = NULL; acb->finished = NULL;

12
block/iscsi.c
View File

@ -133,7 +133,7 @@ iscsi_aio_cancel(BlockDriverAIOCB *blockacb)
} }
} }
static AIOPool iscsi_aio_pool = { static const AIOCBInfo iscsi_aiocb_info = {
.aiocb_size = sizeof(IscsiAIOCB), .aiocb_size = sizeof(IscsiAIOCB),
.cancel = iscsi_aio_cancel, .cancel = iscsi_aio_cancel,
}; };
@ -234,7 +234,7 @@ iscsi_aio_writev(BlockDriverState *bs, int64_t sector_num,
uint64_t lba; uint64_t lba;
struct iscsi_data data; struct iscsi_data data;
acb = qemu_aio_get(&iscsi_aio_pool, bs, cb, opaque); acb = qemu_aio_get(&iscsi_aiocb_info, bs, cb, opaque);
trace_iscsi_aio_writev(iscsi, sector_num, nb_sectors, opaque, acb); trace_iscsi_aio_writev(iscsi, sector_num, nb_sectors, opaque, acb);
acb->iscsilun = iscsilun; acb->iscsilun = iscsilun;
@ -325,7 +325,7 @@ iscsi_aio_readv(BlockDriverState *bs, int64_t sector_num,
qemu_read_size = BDRV_SECTOR_SIZE * (size_t)nb_sectors; qemu_read_size = BDRV_SECTOR_SIZE * (size_t)nb_sectors;
acb = qemu_aio_get(&iscsi_aio_pool, bs, cb, opaque); acb = qemu_aio_get(&iscsi_aiocb_info, bs, cb, opaque);
trace_iscsi_aio_readv(iscsi, sector_num, nb_sectors, opaque, acb); trace_iscsi_aio_readv(iscsi, sector_num, nb_sectors, opaque, acb);
acb->iscsilun = iscsilun; acb->iscsilun = iscsilun;
@ -430,7 +430,7 @@ iscsi_aio_flush(BlockDriverState *bs,
struct iscsi_context *iscsi = iscsilun->iscsi; struct iscsi_context *iscsi = iscsilun->iscsi;
IscsiAIOCB *acb; IscsiAIOCB *acb;
acb = qemu_aio_get(&iscsi_aio_pool, bs, cb, opaque); acb = qemu_aio_get(&iscsi_aiocb_info, bs, cb, opaque);
acb->iscsilun = iscsilun; acb->iscsilun = iscsilun;
acb->canceled = 0; acb->canceled = 0;
@ -483,7 +483,7 @@ iscsi_aio_discard(BlockDriverState *bs,
IscsiAIOCB *acb; IscsiAIOCB *acb;
struct unmap_list list[1]; struct unmap_list list[1];
acb = qemu_aio_get(&iscsi_aio_pool, bs, cb, opaque); acb = qemu_aio_get(&iscsi_aiocb_info, bs, cb, opaque);
acb->iscsilun = iscsilun; acb->iscsilun = iscsilun;
acb->canceled = 0; acb->canceled = 0;
@ -558,7 +558,7 @@ static BlockDriverAIOCB *iscsi_aio_ioctl(BlockDriverState *bs,
assert(req == SG_IO); assert(req == SG_IO);
acb = qemu_aio_get(&iscsi_aio_pool, bs, cb, opaque); acb = qemu_aio_get(&iscsi_aiocb_info, bs, cb, opaque);
acb->iscsilun = iscsilun; acb->iscsilun = iscsilun;
acb->canceled = 0; acb->canceled = 0;

4
block/linux-aio.c
View File

@ -140,7 +140,7 @@ static void laio_cancel(BlockDriverAIOCB *blockacb)
} }
} }
static AIOPool laio_pool = { static const AIOCBInfo laio_aiocb_info = {
.aiocb_size = sizeof(struct qemu_laiocb), .aiocb_size = sizeof(struct qemu_laiocb),
.cancel = laio_cancel, .cancel = laio_cancel,
}; };
@ -154,7 +154,7 @@ BlockDriverAIOCB *laio_submit(BlockDriverState *bs, void *aio_ctx, int fd,
struct iocb *iocbs; struct iocb *iocbs;
off_t offset = sector_num * 512; off_t offset = sector_num * 512;
laiocb = qemu_aio_get(&laio_pool, bs, cb, opaque); laiocb = qemu_aio_get(&laio_aiocb_info, bs, cb, opaque);
laiocb->nbytes = nb_sectors * 512; laiocb->nbytes = nb_sectors * 512;
laiocb->ctx = s; laiocb->ctx = s;
laiocb->ret = -EINPROGRESS; laiocb->ret = -EINPROGRESS;

4
block/qed.c
View File

@ -30,7 +30,7 @@ static void qed_aio_cancel(BlockDriverAIOCB *blockacb)
} }
} }
static AIOPool qed_aio_pool = { static const AIOCBInfo qed_aiocb_info = {
.aiocb_size = sizeof(QEDAIOCB), .aiocb_size = sizeof(QEDAIOCB),
.cancel = qed_aio_cancel, .cancel = qed_aio_cancel,
}; };
@ -1311,7 +1311,7 @@ static BlockDriverAIOCB *qed_aio_setup(BlockDriverState *bs,
BlockDriverCompletionFunc *cb, BlockDriverCompletionFunc *cb,
void *opaque, int flags) void *opaque, int flags)
{ {
QEDAIOCB *acb = qemu_aio_get(&qed_aio_pool, bs, cb, opaque); QEDAIOCB *acb = qemu_aio_get(&qed_aiocb_info, bs, cb, opaque);
trace_qed_aio_setup(bs->opaque, acb, sector_num, nb_sectors, trace_qed_aio_setup(bs->opaque, acb, sector_num, nb_sectors,
opaque, flags); opaque, flags);

4
block/rbd.c
View File

@ -570,7 +570,7 @@ static void qemu_rbd_aio_cancel(BlockDriverAIOCB *blockacb)
acb->cancelled = 1; acb->cancelled = 1;
} }
static AIOPool rbd_aio_pool = { static const AIOCBInfo rbd_aiocb_info = {
.aiocb_size = sizeof(RBDAIOCB), .aiocb_size = sizeof(RBDAIOCB),
.cancel = qemu_rbd_aio_cancel, .cancel = qemu_rbd_aio_cancel,
}; };
@ -672,7 +672,7 @@ static BlockDriverAIOCB *rbd_start_aio(BlockDriverState *bs,
BDRVRBDState *s = bs->opaque; BDRVRBDState *s = bs->opaque;
acb = qemu_aio_get(&rbd_aio_pool, bs, cb, opaque); acb = qemu_aio_get(&rbd_aiocb_info, bs, cb, opaque);
acb->cmd = cmd; acb->cmd = cmd;
acb->qiov = qiov; acb->qiov = qiov;
if (cmd == RBD_AIO_DISCARD) { if (cmd == RBD_AIO_DISCARD) {

4
block/sheepdog.c
View File

@ -420,7 +420,7 @@ static void sd_aio_cancel(BlockDriverAIOCB *blockacb)
acb->canceled = true; acb->canceled = true;
} }
static AIOPool sd_aio_pool = { static const AIOCBInfo sd_aiocb_info = {
.aiocb_size = sizeof(SheepdogAIOCB), .aiocb_size = sizeof(SheepdogAIOCB),
.cancel = sd_aio_cancel, .cancel = sd_aio_cancel,
}; };
@ -431,7 +431,7 @@ static SheepdogAIOCB *sd_aio_setup(BlockDriverState *bs, QEMUIOVector *qiov,
{ {
SheepdogAIOCB *acb; SheepdogAIOCB *acb;
acb = qemu_aio_get(&sd_aio_pool, bs, cb, opaque); acb = qemu_aio_get(&sd_aiocb_info, bs, cb, opaque);
acb->qiov = qiov; acb->qiov = qiov;

4
block/win32-aio.c
View File

@ -131,7 +131,7 @@ static void win32_aio_cancel(BlockDriverAIOCB *blockacb)
} }
} }
static AIOPool win32_aio_pool = { static const AIOCBInfo win32_aiocb_info = {
.aiocb_size = sizeof(QEMUWin32AIOCB), .aiocb_size = sizeof(QEMUWin32AIOCB),
.cancel = win32_aio_cancel, .cancel = win32_aio_cancel,
}; };
@ -145,7 +145,7 @@ BlockDriverAIOCB *win32_aio_submit(BlockDriverState *bs,
uint64_t offset = sector_num * 512; uint64_t offset = sector_num * 512;
DWORD rc; DWORD rc;
waiocb = qemu_aio_get(&win32_aio_pool, bs, cb, opaque); waiocb = qemu_aio_get(&win32_aiocb_info, bs, cb, opaque);
waiocb->nbytes = nb_sectors * 512; waiocb->nbytes = nb_sectors * 512;
waiocb->qiov = qiov; waiocb->qiov = qiov;
waiocb->is_read = (type == QEMU_AIO_READ); waiocb->is_read = (type == QEMU_AIO_READ);

4
dma-helpers.c
View File

@ -195,7 +195,7 @@ static void dma_aio_cancel(BlockDriverAIOCB *acb)
dma_complete(dbs, 0); dma_complete(dbs, 0);
} }
static AIOPool dma_aio_pool = { static const AIOCBInfo dma_aiocb_info = {
.aiocb_size = sizeof(DMAAIOCB), .aiocb_size = sizeof(DMAAIOCB),
.cancel = dma_aio_cancel, .cancel = dma_aio_cancel,
}; };
@ -205,7 +205,7 @@ BlockDriverAIOCB *dma_bdrv_io(
DMAIOFunc *io_func, BlockDriverCompletionFunc *cb, DMAIOFunc *io_func, BlockDriverCompletionFunc *cb,
void *opaque, DMADirection dir) void *opaque, DMADirection dir)
{ {
DMAAIOCB *dbs = qemu_aio_get(&dma_aio_pool, bs, cb, opaque); DMAAIOCB *dbs = qemu_aio_get(&dma_aiocb_info, bs, cb, opaque);
trace_dma_bdrv_io(dbs, bs, sector_num, (dir == DMA_DIRECTION_TO_DEVICE)); trace_dma_bdrv_io(dbs, bs, sector_num, (dir == DMA_DIRECTION_TO_DEVICE));

4
hw/ide/core.c
View File

@ -336,7 +336,7 @@ static void trim_aio_cancel(BlockDriverAIOCB *acb)
qemu_aio_release(iocb); qemu_aio_release(iocb);
} }
static AIOPool trim_aio_pool = { static const AIOCBInfo trim_aiocb_info = {
.aiocb_size = sizeof(TrimAIOCB), .aiocb_size = sizeof(TrimAIOCB),
.cancel = trim_aio_cancel, .cancel = trim_aio_cancel,
}; };
@ -360,7 +360,7 @@ BlockDriverAIOCB *ide_issue_trim(BlockDriverState *bs,
TrimAIOCB *iocb; TrimAIOCB *iocb;
int i, j, ret; int i, j, ret;
iocb = qemu_aio_get(&trim_aio_pool, bs, cb, opaque); iocb = qemu_aio_get(&trim_aiocb_info, bs, cb, opaque);
iocb->bh = qemu_bh_new(ide_trim_bh_cb, iocb); iocb->bh = qemu_bh_new(ide_trim_bh_cb, iocb);
iocb->ret = 0; iocb->ret = 0;

8
qemu-aio.h
View File

@ -21,19 +21,19 @@
typedef struct BlockDriverAIOCB BlockDriverAIOCB; typedef struct BlockDriverAIOCB BlockDriverAIOCB;
typedef void BlockDriverCompletionFunc(void *opaque, int ret); typedef void BlockDriverCompletionFunc(void *opaque, int ret);
typedef struct AIOPool { typedef struct AIOCBInfo {
void (*cancel)(BlockDriverAIOCB *acb); void (*cancel)(BlockDriverAIOCB *acb);
size_t aiocb_size; size_t aiocb_size;
} AIOPool; } AIOCBInfo;
struct BlockDriverAIOCB { struct BlockDriverAIOCB {
AIOPool *pool; const AIOCBInfo *aiocb_info;
BlockDriverState *bs; BlockDriverState *bs;
BlockDriverCompletionFunc *cb; BlockDriverCompletionFunc *cb;
void *opaque; void *opaque;
}; };
void *qemu_aio_get(AIOPool *pool, BlockDriverState *bs, void *qemu_aio_get(const AIOCBInfo *aiocb_info, BlockDriverState *bs,
BlockDriverCompletionFunc *cb, void *opaque); BlockDriverCompletionFunc *cb, void *opaque);
void qemu_aio_release(void *p); void qemu_aio_release(void *p);

4
thread-pool.c
View File

@ -216,7 +216,7 @@ static void thread_pool_cancel(BlockDriverAIOCB *acb)
qemu_mutex_unlock(&lock); qemu_mutex_unlock(&lock);
} }
static AIOPool thread_pool_cb_pool = { static const AIOCBInfo thread_pool_aiocb_info = {
.aiocb_size = sizeof(ThreadPoolElement), .aiocb_size = sizeof(ThreadPoolElement),
.cancel = thread_pool_cancel, .cancel = thread_pool_cancel,
}; };
@ -226,7 +226,7 @@ BlockDriverAIOCB *thread_pool_submit_aio(ThreadPoolFunc *func, void *arg,
{ {
ThreadPoolElement *req; ThreadPoolElement *req;
req = qemu_aio_get(&thread_pool_cb_pool, NULL, cb, opaque); req = qemu_aio_get(&thread_pool_aiocb_info, NULL, cb, opaque);
req->func = func; req->func = func;
req->arg = arg; req->arg = arg;
req->state = THREAD_QUEUED; req->state = THREAD_QUEUED;