Adding "map" to buffer functions that perform host memory mapping.
diff --git a/bindings/python/iree/runtime/hal.h b/bindings/python/iree/runtime/hal.h
index e0d93b6..4230260 100644
--- a/bindings/python/iree/runtime/hal.h
+++ b/bindings/python/iree/runtime/hal.h
@@ -110,8 +110,9 @@
void FillZero(iree_device_size_t byte_offset,
iree_device_size_t byte_length) {
- CheckApiStatus(iree_hal_buffer_zero(raw_ptr(), byte_offset, byte_length),
- "Error zero filling buffer");
+ CheckApiStatus(
+ iree_hal_buffer_map_zero(raw_ptr(), byte_offset, byte_length),
+ "Error zero filling buffer");
}
// TODO(laurenzo): make this take element_type instead.
diff --git a/bindings/tflite/tensor.c b/bindings/tflite/tensor.c
index 1d65159..3f52322 100644
--- a/bindings/tflite/tensor.c
+++ b/bindings/tflite/tensor.c
@@ -246,10 +246,10 @@
IREE_TRACE_ZONE_BEGIN(z0);
IREE_TRACE_ZONE_APPEND_VALUE(z0, tensor->buffer_mapping.contents.data_length);
- // NOTE: we could use a iree_hal_buffer_write_data here but we already have
- // the buffer mapped. If we knew the user would never use TfLiteTensorData and
- // could avoid mapping the buffer it would be more efficient and portable to
- // do the iree_hal_buffer_copy_data.
+ // NOTE: we could use a iree_hal_buffer_map_write here but we already
+ // have the buffer mapped. If we knew the user would never use
+ // TfLiteTensorData and could avoid mapping the buffer it would be more
+ // efficient and portable to do the iree_hal_buffer_map_copy.
memcpy(tensor->buffer_mapping.contents.data, input_data, input_data_size);
IREE_TRACE_ZONE_END(z0);
@@ -266,7 +266,7 @@
IREE_TRACE_ZONE_APPEND_VALUE(
z0, output_tensor->buffer_mapping.contents.data_length);
- // NOTE: as with above we should use an iree_hal_buffer_read_data here.
+ // NOTE: as with above we should use an iree_hal_buffer_map_read here.
memcpy(output_data, output_tensor->buffer_mapping.contents.data,
output_data_size);
diff --git a/iree/hal/allocator.h b/iree/hal/allocator.h
index 2c99da4..71a1583 100644
--- a/iree/hal/allocator.h
+++ b/iree/hal/allocator.h
@@ -139,7 +139,7 @@
// Indicates that the buffer can be used as a transfer source or target on the
// a device queue (such as being the source or target of a DMA operation,
// etc). If not set then the buffer may still be usable for
- // iree_hal_buffer_copy_data but not with queued operations.
+ // iree_hal_buffer_map_copy but not with queued operations.
IREE_HAL_BUFFER_COMPATIBILITY_QUEUE_TRANSFER = 1u << 10,
// Indicates that the buffer can be used as an input/output to a dispatch.
diff --git a/iree/hal/buffer.c b/iree/hal/buffer.c
index cb2b4ab..77b64f6 100644
--- a/iree/hal/buffer.c
+++ b/iree/hal/buffer.c
@@ -503,17 +503,17 @@
// Transfer
//===----------------------------------------------------------------------===//
-IREE_API_EXPORT iree_status_t
-iree_hal_buffer_zero(iree_hal_buffer_t* buffer, iree_device_size_t byte_offset,
- iree_device_size_t byte_length) {
+IREE_API_EXPORT iree_status_t iree_hal_buffer_map_zero(
+ iree_hal_buffer_t* buffer, iree_device_size_t byte_offset,
+ iree_device_size_t byte_length) {
const uint8_t zero = 0;
- return iree_hal_buffer_fill(buffer, byte_offset, byte_length, &zero, 1);
+ return iree_hal_buffer_map_fill(buffer, byte_offset, byte_length, &zero, 1);
}
-IREE_API_EXPORT iree_status_t
-iree_hal_buffer_fill(iree_hal_buffer_t* buffer, iree_device_size_t byte_offset,
- iree_device_size_t byte_length, const void* pattern,
- iree_host_size_t pattern_length) {
+IREE_API_EXPORT iree_status_t iree_hal_buffer_map_fill(
+ iree_hal_buffer_t* buffer, iree_device_size_t byte_offset,
+ iree_device_size_t byte_length, const void* pattern,
+ iree_host_size_t pattern_length) {
IREE_ASSERT_ARGUMENT(buffer);
IREE_ASSERT_ARGUMENT(pattern);
@@ -600,7 +600,7 @@
return status;
}
-IREE_API_EXPORT iree_status_t iree_hal_buffer_read_data(
+IREE_API_EXPORT iree_status_t iree_hal_buffer_map_read(
iree_hal_buffer_t* source_buffer, iree_device_size_t source_offset,
void* target_buffer, iree_device_size_t data_length) {
if (data_length == 0) {
@@ -624,7 +624,7 @@
return iree_ok_status();
}
-IREE_API_EXPORT iree_status_t iree_hal_buffer_write_data(
+IREE_API_EXPORT iree_status_t iree_hal_buffer_map_write(
iree_hal_buffer_t* target_buffer, iree_device_size_t target_offset,
const void* source_buffer, iree_device_size_t data_length) {
if (data_length == 0) {
@@ -655,7 +655,7 @@
return status;
}
-IREE_API_EXPORT iree_status_t iree_hal_buffer_copy_data(
+IREE_API_EXPORT iree_status_t iree_hal_buffer_map_copy(
iree_hal_buffer_t* source_buffer, iree_device_size_t source_offset,
iree_hal_buffer_t* target_buffer, iree_device_size_t target_offset,
iree_device_size_t data_length) {
diff --git a/iree/hal/buffer.h b/iree/hal/buffer.h
index 6af80fa..9ff8bdc 100644
--- a/iree/hal/buffer.h
+++ b/iree/hal/buffer.h
@@ -386,9 +386,9 @@
// queues; using this synchronous function may incur additional cache flushes
// and synchronous blocking behavior and is not supported on all buffer types.
// See iree_hal_command_buffer_fill_buffer.
-IREE_API_EXPORT iree_status_t
-iree_hal_buffer_zero(iree_hal_buffer_t* buffer, iree_device_size_t byte_offset,
- iree_device_size_t byte_length);
+IREE_API_EXPORT iree_status_t iree_hal_buffer_map_zero(
+ iree_hal_buffer_t* buffer, iree_device_size_t byte_offset,
+ iree_device_size_t byte_length);
// Sets a range of the buffer to the given value.
// Only |pattern_length| values with 1, 2, or 4 bytes are supported.
@@ -400,10 +400,10 @@
// queues; using this synchronous function may incur additional cache flushes
// and synchronous blocking behavior and is not supported on all buffer types.
// See iree_hal_command_buffer_fill_buffer.
-IREE_API_EXPORT iree_status_t
-iree_hal_buffer_fill(iree_hal_buffer_t* buffer, iree_device_size_t byte_offset,
- iree_device_size_t byte_length, const void* pattern,
- iree_host_size_t pattern_length);
+IREE_API_EXPORT iree_status_t iree_hal_buffer_map_fill(
+ iree_hal_buffer_t* buffer, iree_device_size_t byte_offset,
+ iree_device_size_t byte_length, const void* pattern,
+ iree_host_size_t pattern_length);
// Reads a block of data from the buffer at the given offset.
//
@@ -413,7 +413,7 @@
// queues; using this synchronous function may incur additional cache flushes
// and synchronous blocking behavior and is not supported on all buffer types.
// See iree_hal_command_buffer_copy_buffer.
-IREE_API_EXPORT iree_status_t iree_hal_buffer_read_data(
+IREE_API_EXPORT iree_status_t iree_hal_buffer_map_read(
iree_hal_buffer_t* source_buffer, iree_device_size_t source_offset,
void* target_buffer, iree_device_size_t data_length);
@@ -427,7 +427,7 @@
// and synchronous blocking behavior and is not supported on all buffer types.
// See iree_hal_command_buffer_update_buffer and
// iree_hal_command_buffer_copy_buffer.
-IREE_API_EXPORT iree_status_t iree_hal_buffer_write_data(
+IREE_API_EXPORT iree_status_t iree_hal_buffer_map_write(
iree_hal_buffer_t* target_buffer, iree_device_size_t target_offset,
const void* source_buffer, iree_device_size_t data_length);
@@ -441,7 +441,7 @@
// queues; using this synchronous function may incur additional cache flushes
// and synchronous blocking behavior and is not supported on all buffer types.
// See iree_hal_command_buffer_copy_buffer.
-IREE_API_EXPORT iree_status_t iree_hal_buffer_copy_data(
+IREE_API_EXPORT iree_status_t iree_hal_buffer_map_copy(
iree_hal_buffer_t* source_buffer, iree_device_size_t source_offset,
iree_hal_buffer_t* target_buffer, iree_device_size_t target_offset,
iree_device_size_t data_length);
diff --git a/iree/hal/cts/buffer_mapping_test.h b/iree/hal/cts/buffer_mapping_test.h
index d1d8cde..2810efa 100644
--- a/iree/hal/cts/buffer_mapping_test.h
+++ b/iree/hal/cts/buffer_mapping_test.h
@@ -31,9 +31,9 @@
//
// Note that most of these tests first write into a buffer using one or more
// functions then read the (possibly partial) contents of that buffer using
-// `iree_hal_buffer_read_data`. As the buffer read implementation is nontrivial,
-// particularly on implementations with complex host/device splits, test
-// failures may indicate issues in either the code doing the writing or the
+// `iree_hal_buffer_map_read`. As the buffer read implementation is
+// nontrivial, particularly on implementations with complex host/device splits,
+// test failures may indicate issues in either the code doing the writing or the
// code doing the reading.
//
// Where applicable, tests for each function are organized in increasing order
@@ -87,11 +87,11 @@
// Zero the entire buffer.
IREE_ASSERT_OK(
- iree_hal_buffer_zero(buffer, /*byte_offset=*/0, IREE_WHOLE_BUFFER));
+ iree_hal_buffer_map_zero(buffer, /*byte_offset=*/0, IREE_WHOLE_BUFFER));
// Check that the contents match what we expect.
std::vector<uint8_t> actual_data(kDefaultAllocationSize);
- IREE_ASSERT_OK(iree_hal_buffer_read_data(
+ IREE_ASSERT_OK(iree_hal_buffer_map_read(
buffer, /*source_offset=*/0, actual_data.data(), actual_data.size()));
std::vector<uint8_t> reference_buffer(kDefaultAllocationSize);
std::memset(reference_buffer.data(), 0, kDefaultAllocationSize);
@@ -107,15 +107,15 @@
// Fill the entire buffer then zero only a segment of it.
uint8_t fill_value = 0xFF;
- IREE_ASSERT_OK(iree_hal_buffer_fill(buffer, /*byte_offset=*/0,
- IREE_WHOLE_BUFFER, &fill_value,
- sizeof(fill_value)));
+ IREE_ASSERT_OK(iree_hal_buffer_map_fill(buffer, /*byte_offset=*/0,
+ IREE_WHOLE_BUFFER, &fill_value,
+ sizeof(fill_value)));
IREE_ASSERT_OK(
- iree_hal_buffer_zero(buffer, /*byte_offset=*/4, /*byte_length=*/8));
+ iree_hal_buffer_map_zero(buffer, /*byte_offset=*/4, /*byte_length=*/8));
// Check that the contents match what we expect.
std::vector<uint8_t> actual_data(buffer_size);
- IREE_ASSERT_OK(iree_hal_buffer_read_data(
+ IREE_ASSERT_OK(iree_hal_buffer_map_read(
buffer, /*source_offset=*/0, actual_data.data(), actual_data.size()));
std::vector<uint8_t> reference_buffer{0xFF, 0xFF, 0xFF, 0xFF, //
0x00, 0x00, 0x00, 0x00, //
@@ -133,9 +133,9 @@
// Fill the entire buffer.
uint8_t fill_value = 0xFF;
- IREE_ASSERT_OK(iree_hal_buffer_fill(buffer, /*byte_offset=*/0,
- IREE_WHOLE_BUFFER, &fill_value,
- sizeof(fill_value)));
+ IREE_ASSERT_OK(iree_hal_buffer_map_fill(buffer, /*byte_offset=*/0,
+ IREE_WHOLE_BUFFER, &fill_value,
+ sizeof(fill_value)));
// Create a subspan.
iree_device_size_t subspan_length = 8;
@@ -144,12 +144,12 @@
subspan_length, &buffer_subspan));
// Zero part of the subspan.
- IREE_ASSERT_OK(iree_hal_buffer_zero(buffer_subspan, /*byte_offset=*/4,
- /*byte_length=*/4));
+ IREE_ASSERT_OK(iree_hal_buffer_map_zero(buffer_subspan, /*byte_offset=*/4,
+ /*byte_length=*/4));
// Check that the contents match what we expect.
std::vector<uint8_t> actual_data(buffer_size);
- IREE_ASSERT_OK(iree_hal_buffer_read_data(
+ IREE_ASSERT_OK(iree_hal_buffer_map_read(
buffer, /*source_offset=*/0, actual_data.data(), actual_data.size()));
std::vector<uint8_t> reference_buffer{0xFF, 0xFF, 0xFF, 0xFF, //
0xFF, 0xFF, 0xFF, 0xFF, //
@@ -158,9 +158,9 @@
EXPECT_THAT(actual_data, ContainerEq(reference_buffer));
// Also check the subspan.
std::vector<uint8_t> actual_data_subspan(subspan_length);
- IREE_ASSERT_OK(iree_hal_buffer_read_data(buffer_subspan, /*source_offset=*/0,
- actual_data_subspan.data(),
- actual_data_subspan.size()));
+ IREE_ASSERT_OK(iree_hal_buffer_map_read(buffer_subspan, /*source_offset=*/0,
+ actual_data_subspan.data(),
+ actual_data_subspan.size()));
std::vector<uint8_t> reference_buffer_subspan{0xFF, 0xFF, 0xFF, 0xFF, //
0x00, 0x00, 0x00, 0x00};
EXPECT_THAT(actual_data_subspan, ContainerEq(reference_buffer_subspan));
@@ -174,16 +174,17 @@
AllocateUninitializedBuffer(kDefaultAllocationSize, &buffer);
// Zero the whole buffer then "fill" 0 bytes with a different pattern.
- IREE_ASSERT_OK(iree_hal_buffer_zero(buffer, 0, IREE_WHOLE_BUFFER));
+ IREE_ASSERT_OK(iree_hal_buffer_map_zero(buffer, 0, IREE_WHOLE_BUFFER));
uint8_t fill_value = 0xFF;
- IREE_ASSERT_OK(iree_hal_buffer_fill(buffer, /*byte_offset=*/0,
- /*byte_length=*/0, // <---- empty!
- /*pattern=*/&fill_value,
- /*pattern_length=*/sizeof(fill_value)));
+ IREE_ASSERT_OK(
+ iree_hal_buffer_map_fill(buffer, /*byte_offset=*/0,
+ /*byte_length=*/0, // <---- empty!
+ /*pattern=*/&fill_value,
+ /*pattern_length=*/sizeof(fill_value)));
// Check that the buffer is still all zeroes.
std::vector<uint8_t> actual_data(kDefaultAllocationSize);
- IREE_ASSERT_OK(iree_hal_buffer_read_data(
+ IREE_ASSERT_OK(iree_hal_buffer_map_read(
buffer, /*source_offset=*/0, actual_data.data(), actual_data.size()));
std::vector<uint8_t> reference_buffer(kDefaultAllocationSize);
std::memset(reference_buffer.data(), 0, kDefaultAllocationSize);
@@ -197,14 +198,15 @@
AllocateUninitializedBuffer(kDefaultAllocationSize, &buffer);
uint8_t fill_value = 0xFF;
- IREE_ASSERT_OK(iree_hal_buffer_fill(buffer, /*byte_offset=*/0,
- /*byte_length=*/IREE_WHOLE_BUFFER,
- /*pattern=*/&fill_value,
- /*pattern_length=*/sizeof(fill_value)));
+ IREE_ASSERT_OK(
+ iree_hal_buffer_map_fill(buffer, /*byte_offset=*/0,
+ /*byte_length=*/IREE_WHOLE_BUFFER,
+ /*pattern=*/&fill_value,
+ /*pattern_length=*/sizeof(fill_value)));
// Check that the buffer is filled with the pattern.
std::vector<uint8_t> actual_data(kDefaultAllocationSize);
- IREE_ASSERT_OK(iree_hal_buffer_read_data(
+ IREE_ASSERT_OK(iree_hal_buffer_map_read(
buffer, /*source_offset=*/0, actual_data.data(), actual_data.size()));
std::vector<uint8_t> reference_buffer(kDefaultAllocationSize);
std::memset(reference_buffer.data(), fill_value, kDefaultAllocationSize);
@@ -219,16 +221,17 @@
AllocateUninitializedBuffer(buffer_size, &buffer);
// Zero the entire buffer then fill only a segment of it.
- IREE_ASSERT_OK(iree_hal_buffer_zero(buffer, 0, IREE_WHOLE_BUFFER));
+ IREE_ASSERT_OK(iree_hal_buffer_map_zero(buffer, 0, IREE_WHOLE_BUFFER));
uint8_t fill_value = 0xFF;
- IREE_ASSERT_OK(iree_hal_buffer_fill(buffer, /*byte_offset=*/4,
- /*byte_length=*/8,
- /*pattern=*/&fill_value,
- /*pattern_length=*/sizeof(fill_value)));
+ IREE_ASSERT_OK(
+ iree_hal_buffer_map_fill(buffer, /*byte_offset=*/4,
+ /*byte_length=*/8,
+ /*pattern=*/&fill_value,
+ /*pattern_length=*/sizeof(fill_value)));
// Check that only the segment of the buffer is filled with the pattern.
std::vector<uint8_t> actual_data(buffer_size);
- IREE_ASSERT_OK(iree_hal_buffer_read_data(
+ IREE_ASSERT_OK(iree_hal_buffer_map_read(
buffer, /*source_offset=*/0, actual_data.data(), actual_data.size()));
std::vector<uint8_t> reference_offset_buffer{0x00, 0x00, 0x00, 0x00, //
0xFF, 0xFF, 0xFF, 0xFF, //
@@ -245,7 +248,7 @@
AllocateUninitializedBuffer(buffer_size, &buffer);
// Zero the entire buffer.
- IREE_ASSERT_OK(iree_hal_buffer_zero(buffer, 0, IREE_WHOLE_BUFFER));
+ IREE_ASSERT_OK(iree_hal_buffer_map_zero(buffer, 0, IREE_WHOLE_BUFFER));
// Create a subspan.
iree_device_size_t subspan_length = 8;
@@ -255,14 +258,15 @@
// Fill part of the subspan.
uint8_t fill_value = 0xFF;
- IREE_ASSERT_OK(iree_hal_buffer_fill(buffer_subspan, /*byte_offset=*/4,
- /*byte_length=*/4,
- /*pattern=*/&fill_value,
- /*pattern_length=*/sizeof(fill_value)));
+ IREE_ASSERT_OK(
+ iree_hal_buffer_map_fill(buffer_subspan, /*byte_offset=*/4,
+ /*byte_length=*/4,
+ /*pattern=*/&fill_value,
+ /*pattern_length=*/sizeof(fill_value)));
// Check that the contents match what we expect.
std::vector<uint8_t> actual_data(buffer_size);
- IREE_ASSERT_OK(iree_hal_buffer_read_data(
+ IREE_ASSERT_OK(iree_hal_buffer_map_read(
buffer, /*source_offset=*/0, actual_data.data(), actual_data.size()));
std::vector<uint8_t> reference_buffer{0x00, 0x00, 0x00, 0x00, //
0x00, 0x00, 0x00, 0x00, //
@@ -271,9 +275,9 @@
EXPECT_THAT(actual_data, ContainerEq(reference_buffer));
// Also check the subspan.
std::vector<uint8_t> actual_data_subspan(subspan_length);
- IREE_ASSERT_OK(iree_hal_buffer_read_data(buffer_subspan, /*source_offset=*/0,
- actual_data_subspan.data(),
- actual_data_subspan.size()));
+ IREE_ASSERT_OK(iree_hal_buffer_map_read(buffer_subspan, /*source_offset=*/0,
+ actual_data_subspan.data(),
+ actual_data_subspan.size()));
std::vector<uint8_t> reference_buffer_subspan{0x00, 0x00, 0x00, 0x00, //
0xFF, 0xFF, 0xFF, 0xFF};
EXPECT_THAT(actual_data_subspan, ContainerEq(reference_buffer_subspan));
@@ -289,16 +293,17 @@
// Zero the first half, fill the second half.
IREE_ASSERT_OK(
- iree_hal_buffer_zero(buffer, /*byte_offset=*/0, /*byte_length=*/8));
+ iree_hal_buffer_map_zero(buffer, /*byte_offset=*/0, /*byte_length=*/8));
uint8_t fill_value = 0xFF;
- IREE_ASSERT_OK(iree_hal_buffer_fill(buffer, /*byte_offset=*/8,
- /*byte_length=*/8,
- /*pattern=*/&fill_value,
- /*pattern_length=*/sizeof(fill_value)));
+ IREE_ASSERT_OK(
+ iree_hal_buffer_map_fill(buffer, /*byte_offset=*/8,
+ /*byte_length=*/8,
+ /*pattern=*/&fill_value,
+ /*pattern_length=*/sizeof(fill_value)));
// Read the entire buffer.
std::vector<uint8_t> actual_data(buffer_size);
- IREE_ASSERT_OK(iree_hal_buffer_read_data(
+ IREE_ASSERT_OK(iree_hal_buffer_map_read(
buffer, /*source_offset=*/0, actual_data.data(), actual_data.size()));
std::vector<uint8_t> reference_buffer{0x00, 0x00, 0x00, 0x00, //
0x00, 0x00, 0x00, 0x00, //
@@ -308,9 +313,9 @@
// Read only a segment of the buffer.
std::vector<uint8_t> actual_data_offset(8);
- IREE_ASSERT_OK(iree_hal_buffer_read_data(buffer, /*source_offset=*/4,
- actual_data_offset.data(),
- actual_data_offset.size()));
+ IREE_ASSERT_OK(iree_hal_buffer_map_read(buffer, /*source_offset=*/4,
+ actual_data_offset.data(),
+ actual_data_offset.size()));
std::vector<uint8_t> reference_buffer_offset{0x00, 0x00, 0x00, 0x00, //
0xFF, 0xFF, 0xFF, 0xFF};
EXPECT_THAT(actual_data_offset, ContainerEq(reference_buffer_offset));
@@ -325,13 +330,14 @@
// Fill a few segments with distinct values.
uint8_t value = 0xAA;
- IREE_ASSERT_OK(iree_hal_buffer_fill(buffer, 0, 4, &value, sizeof(value)));
+ IREE_ASSERT_OK(iree_hal_buffer_map_fill(buffer, 0, 4, &value, sizeof(value)));
value = 0xBB;
- IREE_ASSERT_OK(iree_hal_buffer_fill(buffer, 4, 4, &value, sizeof(value)));
+ IREE_ASSERT_OK(iree_hal_buffer_map_fill(buffer, 4, 4, &value, sizeof(value)));
value = 0xCC;
- IREE_ASSERT_OK(iree_hal_buffer_fill(buffer, 8, 4, &value, sizeof(value)));
+ IREE_ASSERT_OK(iree_hal_buffer_map_fill(buffer, 8, 4, &value, sizeof(value)));
value = 0xDD;
- IREE_ASSERT_OK(iree_hal_buffer_fill(buffer, 12, 4, &value, sizeof(value)));
+ IREE_ASSERT_OK(
+ iree_hal_buffer_map_fill(buffer, 12, 4, &value, sizeof(value)));
// Create a subspan.
iree_device_size_t subspan_length = 8;
@@ -341,18 +347,18 @@
// Read the entire buffer subspan.
std::vector<uint8_t> actual_data(subspan_length);
- IREE_ASSERT_OK(iree_hal_buffer_read_data(buffer_subspan, /*source_offset=*/0,
- actual_data.data(),
- actual_data.size()));
+ IREE_ASSERT_OK(iree_hal_buffer_map_read(buffer_subspan, /*source_offset=*/0,
+ actual_data.data(),
+ actual_data.size()));
std::vector<uint8_t> reference_buffer{0xBB, 0xBB, 0xBB, 0xBB, //
0xCC, 0xCC, 0xCC, 0xCC};
EXPECT_THAT(actual_data, ContainerEq(reference_buffer));
// Read only a segment of the buffer.
std::vector<uint8_t> actual_data_offset(4);
- IREE_ASSERT_OK(iree_hal_buffer_read_data(buffer_subspan, /*source_offset=*/4,
- actual_data_offset.data(),
- actual_data_offset.size()));
+ IREE_ASSERT_OK(iree_hal_buffer_map_read(buffer_subspan, /*source_offset=*/4,
+ actual_data_offset.data(),
+ actual_data_offset.size()));
std::vector<uint8_t> reference_buffer_offset{0xCC, 0xCC, 0xCC, 0xCC};
EXPECT_THAT(actual_data_offset, ContainerEq(reference_buffer_offset));
@@ -369,13 +375,13 @@
uint8_t fill_value = 0xFF;
std::vector<uint8_t> reference_buffer(buffer_size);
std::memset(reference_buffer.data(), fill_value, buffer_size);
- IREE_ASSERT_OK(iree_hal_buffer_write_data(buffer, /*target_offset=*/0,
- reference_buffer.data(),
- reference_buffer.size()));
+ IREE_ASSERT_OK(iree_hal_buffer_map_write(buffer, /*target_offset=*/0,
+ reference_buffer.data(),
+ reference_buffer.size()));
// Check that entire buffer was written to.
std::vector<uint8_t> actual_data(buffer_size);
- IREE_ASSERT_OK(iree_hal_buffer_read_data(
+ IREE_ASSERT_OK(iree_hal_buffer_map_read(
buffer, /*source_offset=*/0, actual_data.data(), actual_data.size()));
EXPECT_THAT(actual_data, ContainerEq(reference_buffer));
@@ -388,17 +394,17 @@
AllocateUninitializedBuffer(buffer_size, &buffer);
// Zero the entire buffer.
- IREE_ASSERT_OK(iree_hal_buffer_zero(buffer, 0, IREE_WHOLE_BUFFER));
+ IREE_ASSERT_OK(iree_hal_buffer_map_zero(buffer, 0, IREE_WHOLE_BUFFER));
// Write over part of the buffer.
std::vector<uint8_t> fill_buffer{0x11, 0x22, 0x33, 0x44, //
0x55, 0x66, 0x77, 0x88};
- IREE_ASSERT_OK(iree_hal_buffer_write_data(
+ IREE_ASSERT_OK(iree_hal_buffer_map_write(
buffer, /*target_offset=*/4, fill_buffer.data(), fill_buffer.size()));
// Check that the contents match what we expect.
std::vector<uint8_t> actual_data(buffer_size);
- IREE_ASSERT_OK(iree_hal_buffer_read_data(
+ IREE_ASSERT_OK(iree_hal_buffer_map_read(
buffer, /*source_offset=*/0, actual_data.data(), actual_data.size()));
std::vector<uint8_t> reference_buffer{0x00, 0x00, 0x00, 0x00, //
0x11, 0x22, 0x33, 0x44, //
@@ -415,7 +421,7 @@
AllocateUninitializedBuffer(buffer_size, &buffer);
// Zero the entire buffer.
- IREE_ASSERT_OK(iree_hal_buffer_zero(buffer, 0, IREE_WHOLE_BUFFER));
+ IREE_ASSERT_OK(iree_hal_buffer_map_zero(buffer, 0, IREE_WHOLE_BUFFER));
// Create a subspan.
iree_device_size_t subspan_length = 8;
@@ -425,13 +431,13 @@
// Write over part of the subspan.
std::vector<uint8_t> fill_buffer{0x11, 0x22, 0x33, 0x44};
- IREE_ASSERT_OK(iree_hal_buffer_write_data(buffer_subspan, /*target_offset=*/4,
- fill_buffer.data(),
- fill_buffer.size()));
+ IREE_ASSERT_OK(iree_hal_buffer_map_write(buffer_subspan, /*target_offset=*/4,
+ fill_buffer.data(),
+ fill_buffer.size()));
// Check that the contents match what we expect.
std::vector<uint8_t> actual_data(buffer_size);
- IREE_ASSERT_OK(iree_hal_buffer_read_data(
+ IREE_ASSERT_OK(iree_hal_buffer_map_read(
buffer, /*source_offset=*/0, actual_data.data(), actual_data.size()));
std::vector<uint8_t> reference_buffer{0x00, 0x00, 0x00, 0x00, //
0x00, 0x00, 0x00, 0x00, //
@@ -440,9 +446,9 @@
EXPECT_THAT(actual_data, ContainerEq(reference_buffer));
// Also check the subspan.
std::vector<uint8_t> actual_data_subspan(subspan_length);
- IREE_ASSERT_OK(iree_hal_buffer_read_data(buffer_subspan, /*source_offset=*/0,
- actual_data_subspan.data(),
- actual_data_subspan.size()));
+ IREE_ASSERT_OK(iree_hal_buffer_map_read(buffer_subspan, /*source_offset=*/0,
+ actual_data_subspan.data(),
+ actual_data_subspan.size()));
std::vector<uint8_t> reference_buffer_subspan{0x00, 0x00, 0x00, 0x00, //
0x11, 0x22, 0x33, 0x44};
EXPECT_THAT(actual_data_subspan, ContainerEq(reference_buffer_subspan));
@@ -458,11 +464,12 @@
AllocateUninitializedBuffer(kDefaultAllocationSize, &buffer_b);
uint8_t fill_value = 0x07;
- IREE_ASSERT_OK(iree_hal_buffer_fill(buffer_a, /*byte_offset=*/0,
- /*byte_length=*/kDefaultAllocationSize,
- /*pattern=*/&fill_value,
- /*pattern_length=*/sizeof(fill_value)));
- IREE_ASSERT_OK(iree_hal_buffer_copy_data(
+ IREE_ASSERT_OK(
+ iree_hal_buffer_map_fill(buffer_a, /*byte_offset=*/0,
+ /*byte_length=*/kDefaultAllocationSize,
+ /*pattern=*/&fill_value,
+ /*pattern_length=*/sizeof(fill_value)));
+ IREE_ASSERT_OK(iree_hal_buffer_map_copy(
/*source_buffer=*/buffer_a,
/*source_offset=*/0, /*target_buffer=*/buffer_b, /*target_offset=*/0,
/*data_length=*/kDefaultAllocationSize));
@@ -471,7 +478,7 @@
std::memset(reference_buffer.data(), fill_value, kDefaultAllocationSize);
std::vector<uint8_t> actual_data(kDefaultAllocationSize);
- IREE_ASSERT_OK(iree_hal_buffer_read_data(
+ IREE_ASSERT_OK(iree_hal_buffer_map_read(
buffer_b, /*source_offset=*/0, actual_data.data(), actual_data.size()));
EXPECT_THAT(actual_data, ContainerEq(reference_buffer));
@@ -480,16 +487,16 @@
}
// Maps a buffer range for reading from device -> host.
-// This is roughly what iree_hal_buffer_read_data does internally.
+// This is roughly what iree_hal_buffer_map_read does internally.
TEST_P(buffer_mapping_test, MapRangeRead) {
iree_device_size_t buffer_size = 16;
iree_hal_buffer_t* buffer = NULL;
AllocateUninitializedBuffer(buffer_size, &buffer);
uint8_t fill_value = 0xEF;
- IREE_ASSERT_OK(iree_hal_buffer_fill(buffer, /*byte_offset=*/0,
- IREE_WHOLE_BUFFER, &fill_value,
- sizeof(fill_value)));
+ IREE_ASSERT_OK(iree_hal_buffer_map_fill(buffer, /*byte_offset=*/0,
+ IREE_WHOLE_BUFFER, &fill_value,
+ sizeof(fill_value)));
iree_hal_buffer_mapping_t mapping;
IREE_ASSERT_OK(iree_hal_buffer_map_range(
@@ -510,7 +517,7 @@
}
// Maps a buffer range for writing from host -> device.
-// This is roughly what iree_hal_buffer_write_data does internally.
+// This is roughly what iree_hal_buffer_map_write does internally.
TEST_P(buffer_mapping_test, MapRangeWrite) {
iree_device_size_t buffer_size = 16;
iree_hal_buffer_t* buffer = NULL;
@@ -530,7 +537,7 @@
IREE_ASSERT_OK(iree_hal_buffer_flush_range(&mapping, /*byte_offset=*/0,
/*byte_length=*/buffer_size));
std::vector<uint8_t> actual_data(buffer_size);
- IREE_ASSERT_OK(iree_hal_buffer_read_data(
+ IREE_ASSERT_OK(iree_hal_buffer_map_read(
buffer, /*source_offset=*/0, actual_data.data(), actual_data.size()));
std::vector<uint8_t> reference_buffer(buffer_size);
std::memset(reference_buffer.data(), fill_value, buffer_size);
diff --git a/iree/hal/cts/command_buffer_test.h b/iree/hal/cts/command_buffer_test.h
index 6dcb621..3c31e03 100644
--- a/iree/hal/cts/command_buffer_test.h
+++ b/iree/hal/cts/command_buffer_test.h
@@ -38,7 +38,8 @@
IREE_CHECK_OK(iree_hal_allocator_allocate_buffer(
iree_hal_device_allocator(device_), params, buffer_size,
iree_const_byte_span_empty(), &device_buffer));
- IREE_ASSERT_OK(iree_hal_buffer_zero(device_buffer, 0, IREE_WHOLE_BUFFER));
+ IREE_ASSERT_OK(
+ iree_hal_buffer_map_zero(device_buffer, 0, IREE_WHOLE_BUFFER));
*out_buffer = device_buffer;
}
diff --git a/iree/hal/local/inline_command_buffer.c b/iree/hal/local/inline_command_buffer.c
index adc426e..e9aca83 100644
--- a/iree/hal/local/inline_command_buffer.c
+++ b/iree/hal/local/inline_command_buffer.c
@@ -278,8 +278,8 @@
iree_hal_buffer_t* target_buffer, iree_device_size_t target_offset,
iree_device_size_t length, const void* pattern,
iree_host_size_t pattern_length) {
- return iree_hal_buffer_fill(target_buffer, target_offset, length, pattern,
- pattern_length);
+ return iree_hal_buffer_map_fill(target_buffer, target_offset, length, pattern,
+ pattern_length);
}
//===----------------------------------------------------------------------===//
@@ -290,7 +290,7 @@
iree_hal_command_buffer_t* base_command_buffer, const void* source_buffer,
iree_host_size_t source_offset, iree_hal_buffer_t* target_buffer,
iree_device_size_t target_offset, iree_device_size_t length) {
- return iree_hal_buffer_write_data(
+ return iree_hal_buffer_map_write(
target_buffer, target_offset,
(const uint8_t*)source_buffer + source_offset, length);
}
@@ -304,8 +304,8 @@
iree_hal_buffer_t* source_buffer, iree_device_size_t source_offset,
iree_hal_buffer_t* target_buffer, iree_device_size_t target_offset,
iree_device_size_t length) {
- return iree_hal_buffer_copy_data(source_buffer, source_offset, target_buffer,
- target_offset, length);
+ return iree_hal_buffer_map_copy(source_buffer, source_offset, target_buffer,
+ target_offset, length);
}
//===----------------------------------------------------------------------===//
diff --git a/iree/hal/local/task_command_buffer.c b/iree/hal/local/task_command_buffer.c
index 9412063..10313a7 100644
--- a/iree/hal/local/task_command_buffer.c
+++ b/iree/hal/local/task_command_buffer.c
@@ -516,7 +516,7 @@
iree_min(length_per_slice, remaining_length);
IREE_TRACE_ZONE_APPEND_VALUE(z0, (uint64_t)slice_length);
- iree_status_t status = iree_hal_buffer_fill(
+ iree_status_t status = iree_hal_buffer_map_fill(
cmd->target_buffer, cmd->target_offset + slice_offset, slice_length,
cmd->pattern, cmd->pattern_length);
@@ -581,7 +581,7 @@
const iree_hal_cmd_update_buffer_t* cmd =
(const iree_hal_cmd_update_buffer_t*)user_context;
IREE_TRACE_ZONE_BEGIN(z0);
- iree_status_t status = iree_hal_buffer_write_data(
+ iree_status_t status = iree_hal_buffer_map_write(
cmd->target_buffer, cmd->target_offset, cmd->source_buffer, cmd->length);
IREE_TRACE_ZONE_END(z0);
return status;
@@ -655,7 +655,7 @@
iree_min(length_per_slice, remaining_length);
IREE_TRACE_ZONE_APPEND_VALUE(z0, (uint64_t)slice_length);
- iree_status_t status = iree_hal_buffer_copy_data(
+ iree_status_t status = iree_hal_buffer_map_copy(
cmd->source_buffer, cmd->source_offset + slice_offset, cmd->target_buffer,
cmd->target_offset + slice_offset, slice_length);
diff --git a/iree/hal/string_util_test.cc b/iree/hal/string_util_test.cc
index 22e9063..453f99c 100644
--- a/iree/hal/string_util_test.cc
+++ b/iree/hal/string_util_test.cc
@@ -411,7 +411,7 @@
iree_device_size_t total_byte_length = byte_length();
std::vector<T> result(total_byte_length / sizeof(T));
iree_status_t status =
- iree_hal_buffer_read_data(get(), 0, result.data(), total_byte_length);
+ iree_hal_buffer_map_read(get(), 0, result.data(), total_byte_length);
IREE_RETURN_IF_ERROR(std::move(status));
return std::move(result);
}
diff --git a/iree/hal/utils/buffer_transfer.c b/iree/hal/utils/buffer_transfer.c
index ce619b1..553d049 100644
--- a/iree/hal/utils/buffer_transfer.c
+++ b/iree/hal/utils/buffer_transfer.c
@@ -123,8 +123,8 @@
// Read back the staging buffer into memory, if needed.
if (iree_status_is_ok(status) && !target.device_buffer) {
- status = iree_hal_buffer_read_data(target_buffer, 0,
- target.host_buffer.data, data_length);
+ status = iree_hal_buffer_map_read(target_buffer, 0, target.host_buffer.data,
+ data_length);
}
// Discard staging buffers, if they were required.
diff --git a/iree/tools/iree-e2e-matmul-test.c b/iree/tools/iree-e2e-matmul-test.c
index fb27add..ac3c027 100644
--- a/iree/tools/iree-e2e-matmul-test.c
+++ b/iree/tools/iree-e2e-matmul-test.c
@@ -492,8 +492,8 @@
static iree_status_t copy_buffer(iree_hal_allocator_t* hal_allocator,
iree_hal_buffer_view_t* src,
iree_hal_buffer_view_t** dst) {
- // TODO(benvanik): change this to use iree_hal_buffer_copy_data. Or something.
- // I can't understand what all this code is doing.
+ // TODO(benvanik): change this to use iree_hal_buffer_map_copy. Or
+ // something. I can't understand what all this code is doing.
iree_hal_buffer_mapping_t src_mapping = {{0}};
IREE_RETURN_IF_ERROR(iree_hal_buffer_map_range(
iree_hal_buffer_view_buffer(src), IREE_HAL_MAPPING_MODE_PERSISTENT,
