Skip to content

Commit 0ba0b97

Browse files
lplewalplewa
authored
Merge pull request #770 from ldorau/Implement_more_API_of_the_Coarse_provider
Implement split()/merge() API of the Coarse provider
2 parents 9fc6aa3 + 3a5b33c commit 0ba0b97

File tree

2 files changed

+392
-6
lines changed

2 files changed

+392
-6
lines changed

‎src/provider/provider_coarse.c

Lines changed: 184 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -1204,7 +1204,7 @@ static umf_result_t coarse_memory_provider_alloc(void *provider, size_t size,
12041204
(struct coarse_memory_provider_t *)provider;
12051205

12061206
if (utils_mutex_lock(&coarse_provider->lock) != 0) {
1207-
LOG_ERR("lockng the lock failed");
1207+
LOG_ERR("locking the lock failed");
12081208
return UMF_RESULT_ERROR_UNKNOWN;
12091209
}
12101210

@@ -1329,7 +1329,7 @@ static umf_result_t coarse_memory_provider_free(void *provider, void *ptr,
13291329
(struct coarse_memory_provider_t *)provider;
13301330

13311331
if (utils_mutex_lock(&coarse_provider->lock) != 0) {
1332-
LOG_ERR("lockng the lock failed");
1332+
LOG_ERR("locking the lock failed");
13331333
return UMF_RESULT_ERROR_UNKNOWN;
13341334
}
13351335

@@ -1351,7 +1351,12 @@ static umf_result_t coarse_memory_provider_free(void *provider, void *ptr,
13511351
return UMF_RESULT_ERROR_INVALID_ARGUMENT;
13521352
}
13531353

1354-
assert(bytes == 0 || bytes == block->size);
1354+
if (bytes > 0 && bytes != block->size) {
1355+
// wrong size of allocation
1356+
utils_mutex_unlock(&coarse_provider->lock);
1357+
LOG_ERR("wrong size of allocation");
1358+
return UMF_RESULT_ERROR_INVALID_ARGUMENT;
1359+
}
13551360

13561361
LOG_DEBUG("coarse_FREE (return_block_to_pool) %zu used %zu alloc %zu",
13571362
block->size, coarse_provider->used_size - block->size,
@@ -1511,6 +1516,179 @@ coarse_memory_provider_get_stats(void *provider,
15111516
return UMF_RESULT_SUCCESS;
15121517
}
15131518

1519+
static umf_result_t coarse_memory_provider_allocation_split(void *provider,
1520+
void *ptr,
1521+
size_t totalSize,
1522+
size_t firstSize) {
1523+
if (provider == NULL || ptr == NULL || (firstSize >= totalSize) ||
1524+
firstSize == 0) {
1525+
return UMF_RESULT_ERROR_INVALID_ARGUMENT;
1526+
}
1527+
1528+
umf_result_t umf_result;
1529+
1530+
coarse_memory_provider_t *coarse_provider =
1531+
(struct coarse_memory_provider_t *)provider;
1532+
1533+
if (utils_mutex_lock(&coarse_provider->lock) != 0) {
1534+
LOG_ERR("locking the lock failed");
1535+
return UMF_RESULT_ERROR_UNKNOWN;
1536+
}
1537+
1538+
assert(debug_check(coarse_provider));
1539+
1540+
ravl_node_t *node = coarse_ravl_find_node(coarse_provider->all_blocks, ptr);
1541+
if (node == NULL) {
1542+
LOG_ERR("memory block not found");
1543+
umf_result = UMF_RESULT_ERROR_INVALID_ARGUMENT;
1544+
goto err_mutex_unlock;
1545+
}
1546+
1547+
block_t *block = get_node_block(node);
1548+
1549+
if (block->size != totalSize) {
1550+
LOG_ERR("wrong totalSize");
1551+
umf_result = UMF_RESULT_ERROR_INVALID_ARGUMENT;
1552+
goto err_mutex_unlock;
1553+
}
1554+
1555+
if (!block->used) {
1556+
LOG_ERR("block is not allocated");
1557+
umf_result = UMF_RESULT_ERROR_INVALID_ARGUMENT;
1558+
goto err_mutex_unlock;
1559+
}
1560+
1561+
block_t *new_block = coarse_ravl_add_new(coarse_provider->all_blocks,
1562+
block->data + firstSize,
1563+
block->size - firstSize, NULL);
1564+
if (new_block == NULL) {
1565+
umf_result = UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
1566+
goto err_mutex_unlock;
1567+
}
1568+
1569+
block->size = firstSize;
1570+
new_block->used = true;
1571+
1572+
assert(new_block->size == (totalSize - firstSize));
1573+
1574+
umf_result = UMF_RESULT_SUCCESS;
1575+
1576+
err_mutex_unlock:
1577+
assert(debug_check(coarse_provider));
1578+
1579+
if (utils_mutex_unlock(&coarse_provider->lock) != 0) {
1580+
LOG_ERR("unlocking the lock failed");
1581+
if (umf_result == UMF_RESULT_SUCCESS) {
1582+
umf_result = UMF_RESULT_ERROR_UNKNOWN;
1583+
}
1584+
}
1585+
1586+
return umf_result;
1587+
}
1588+
1589+
static umf_result_t coarse_memory_provider_allocation_merge(void *provider,
1590+
void *lowPtr,
1591+
void *highPtr,
1592+
size_t totalSize) {
1593+
if (provider == NULL || lowPtr == NULL || highPtr == NULL ||
1594+
((uintptr_t)highPtr <= (uintptr_t)lowPtr) ||
1595+
((uintptr_t)highPtr - (uintptr_t)lowPtr >= totalSize)) {
1596+
return UMF_RESULT_ERROR_INVALID_ARGUMENT;
1597+
}
1598+
1599+
umf_result_t umf_result;
1600+
1601+
coarse_memory_provider_t *coarse_provider =
1602+
(struct coarse_memory_provider_t *)provider;
1603+
1604+
if (utils_mutex_lock(&coarse_provider->lock) != 0) {
1605+
LOG_ERR("locking the lock failed");
1606+
return UMF_RESULT_ERROR_UNKNOWN;
1607+
}
1608+
1609+
assert(debug_check(coarse_provider));
1610+
1611+
ravl_node_t *low_node =
1612+
coarse_ravl_find_node(coarse_provider->all_blocks, lowPtr);
1613+
if (low_node == NULL) {
1614+
LOG_ERR("the lowPtr memory block not found");
1615+
umf_result = UMF_RESULT_ERROR_INVALID_ARGUMENT;
1616+
goto err_mutex_unlock;
1617+
}
1618+
1619+
block_t *low_block = get_node_block(low_node);
1620+
if (!low_block->used) {
1621+
LOG_ERR("the lowPtr block is not allocated");
1622+
umf_result = UMF_RESULT_ERROR_INVALID_ARGUMENT;
1623+
goto err_mutex_unlock;
1624+
}
1625+
1626+
ravl_node_t *high_node =
1627+
coarse_ravl_find_node(coarse_provider->all_blocks, highPtr);
1628+
if (high_node == NULL) {
1629+
LOG_ERR("the highPtr memory block not found");
1630+
umf_result = UMF_RESULT_ERROR_INVALID_ARGUMENT;
1631+
goto err_mutex_unlock;
1632+
}
1633+
1634+
block_t *high_block = get_node_block(high_node);
1635+
if (!high_block->used) {
1636+
LOG_ERR("the highPtr block is not allocated");
1637+
umf_result = UMF_RESULT_ERROR_INVALID_ARGUMENT;
1638+
goto err_mutex_unlock;
1639+
}
1640+
1641+
if (get_node_next(low_node) != high_node) {
1642+
LOG_ERR("given pointers cannot be merged");
1643+
umf_result = UMF_RESULT_ERROR_INVALID_ARGUMENT;
1644+
goto err_mutex_unlock;
1645+
}
1646+
1647+
if (get_node_prev(high_node) != low_node) {
1648+
LOG_ERR("given pointers cannot be merged");
1649+
umf_result = UMF_RESULT_ERROR_INVALID_ARGUMENT;
1650+
goto err_mutex_unlock;
1651+
}
1652+
1653+
if (low_block->size + high_block->size != totalSize) {
1654+
LOG_ERR("wrong totalSize");
1655+
umf_result = UMF_RESULT_ERROR_INVALID_ARGUMENT;
1656+
goto err_mutex_unlock;
1657+
}
1658+
1659+
if ((uintptr_t)highPtr != ((uintptr_t)lowPtr + low_block->size)) {
1660+
LOG_ERR("given pointers cannot be merged");
1661+
umf_result = UMF_RESULT_ERROR_INVALID_ARGUMENT;
1662+
goto err_mutex_unlock;
1663+
}
1664+
1665+
ravl_node_t *merged_node = NULL;
1666+
1667+
umf_result = user_block_merge(coarse_provider, low_node, high_node, true,
1668+
&merged_node);
1669+
if (umf_result != UMF_RESULT_SUCCESS) {
1670+
LOG_ERR("merging failed");
1671+
goto err_mutex_unlock;
1672+
}
1673+
1674+
assert(merged_node == low_node);
1675+
assert(low_block->size == totalSize);
1676+
1677+
umf_result = UMF_RESULT_SUCCESS;
1678+
1679+
err_mutex_unlock:
1680+
assert(debug_check(coarse_provider));
1681+
1682+
if (utils_mutex_unlock(&coarse_provider->lock) != 0) {
1683+
LOG_ERR("unlocking the lock failed");
1684+
if (umf_result == UMF_RESULT_SUCCESS) {
1685+
umf_result = UMF_RESULT_ERROR_UNKNOWN;
1686+
}
1687+
}
1688+
1689+
return umf_result;
1690+
}
1691+
15141692
umf_memory_provider_ops_t UMF_COARSE_MEMORY_PROVIDER_OPS = {
15151693
.version = UMF_VERSION_CURRENT,
15161694
.initialize = coarse_memory_provider_initialize,
@@ -1522,12 +1700,12 @@ umf_memory_provider_ops_t UMF_COARSE_MEMORY_PROVIDER_OPS = {
15221700
.get_min_page_size = coarse_memory_provider_get_min_page_size,
15231701
.get_name = coarse_memory_provider_get_name,
15241702
.ext.free = coarse_memory_provider_free,
1703+
.ext.allocation_merge = coarse_memory_provider_allocation_merge,
1704+
.ext.allocation_split = coarse_memory_provider_allocation_split,
15251705
// TODO
15261706
/*
15271707
.ext.purge_lazy = coarse_memory_provider_purge_lazy,
15281708
.ext.purge_force = coarse_memory_provider_purge_force,
1529-
.ext.allocation_merge = coarse_memory_provider_allocation_merge,
1530-
.ext.allocation_split = coarse_memory_provider_allocation_split,
15311709
.ipc.get_ipc_handle_size = coarse_memory_provider_get_ipc_handle_size,
15321710
.ipc.get_ipc_handle = coarse_memory_provider_get_ipc_handle,
15331711
.ipc.put_ipc_handle = coarse_memory_provider_put_ipc_handle,
@@ -1554,7 +1732,7 @@ umfCoarseMemoryProviderGetStats(umf_memory_provider_handle_t provider) {
15541732
(struct coarse_memory_provider_t *)priv;
15551733

15561734
if (utils_mutex_lock(&coarse_provider->lock) != 0) {
1557-
LOG_ERR("lockng the lock failed");
1735+
LOG_ERR("locking the lock failed");
15581736
return stats;
15591737
}
15601738

0 commit comments

Comments
 (0)