fix some errors

TingDaoK · TingDaoK · commit a58305c4d12a · 2025-10-07T15:51:51.000-07:00
diff --git a/source/s3_util.c b/source/s3_util.c
@@ -78,7 +78,7 @@ const uint64_t g_default_part_size_fallback = MB_TO_BYTES(8);
 const uint64_t g_default_max_part_size = 5368709120ULL;
 
 /* TODO: Use a reasonable alignment with the update of the buffer pool */
-const uint64_t g_s3_optimal_range_size_alignment = MB_TO_BYTES(32);
+const uint64_t g_s3_optimal_range_size_alignment = 1;
 /**
  * The most parts in memory will be:
  * - All downloaded parts to deliver them in the right order (download)
@@ -786,7 +786,14 @@ int aws_s3_check_headers_for_checksum(
     return AWS_OP_SUCCESS;
 }
 
-int aws_s3_range_size_alignment(uint64_t *range_size) {}
+static void s_s3_range_size_alignment(uint64_t *range_size) {
+    /* TODO: Round up the part size should be part of the memory pool impl. We should let memory pool to decide
+     * what's the best round up for the part size. */
+    if (*range_size > g_s3_optimal_range_size_alignment && *range_size % g_s3_optimal_range_size_alignment != 0) {
+        /* Only apply alignment for sizes above minimum to avoid excessive rounding */
+        *range_size = ((*range_size / g_s3_optimal_range_size_alignment) + 1) * g_s3_optimal_range_size_alignment;
+    }
+}
 
 int aws_s3_calculate_client_optimal_range_size(
     uint64_t memory_limit_in_bytes,
@@ -821,12 +828,7 @@ int aws_s3_calculate_client_optimal_range_size(
     if (optimal_size < g_default_part_size_fallback) {
         optimal_size = g_default_part_size_fallback;
     } else {
-        /* Only apply alignment for sizes above minimum to avoid excessive rounding */
-        /* TODO: Round up the part size should be part of the memory pool impl. We should let memory pool to decide
-         * what's the best round up for the part size. */
-        if (optimal_size > g_s3_optimal_range_size_alignment && optimal_size % g_s3_optimal_range_size_alignment != 0) {
-            optimal_size = ((optimal_size / g_s3_optimal_range_size_alignment) + 1) * g_s3_optimal_range_size_alignment;
-        }
+        s_s3_range_size_alignment(&optimal_size);
     }
 
     /* Apply maximum constraint */
@@ -875,14 +877,7 @@ int aws_s3_calculate_request_optimal_range_size(
         if (optimal_size < g_default_part_size_fallback) {
             optimal_size = g_default_part_size_fallback;
         } else {
-            /* Only apply alignment for sizes above minimum to avoid excessive rounding */
-            /* TODO: Round up the part size should be part of the memory pool impl. We should let memory pool to decide
-             * what's the best round up for the part size. */
-            if (optimal_size > g_s3_optimal_range_size_alignment &&
-                optimal_size % g_s3_optimal_range_size_alignment != 0) {
-                optimal_size =
-                    ((optimal_size / g_s3_optimal_range_size_alignment) + 1) * g_s3_optimal_range_size_alignment;
-            }
+            s_s3_range_size_alignment(&optimal_size);
         }
     }
 
diff --git a/tests/s3_util_tests.c b/tests/s3_util_tests.c
@@ -782,6 +782,15 @@ static int s_test_s3_aws_xml_get_body_at_path(struct aws_allocator *allocator, v
     return AWS_OP_SUCCESS;
 }
 
+static void s_s3_range_size_alignment(uint64_t *range_size) {
+    /* TODO: Round up the part size should be part of the memory pool impl. We should let memory pool to decide
+     * what's the best round up for the part size. */
+    if (*range_size > g_s3_optimal_range_size_alignment && *range_size % g_s3_optimal_range_size_alignment != 0) {
+        /* Only apply alignment for sizes above minimum to avoid excessive rounding */
+        *range_size = ((*range_size / g_s3_optimal_range_size_alignment) + 1) * g_s3_optimal_range_size_alignment;
+    }
+}
+
 AWS_TEST_CASE(test_s3_calculate_client_optimal_range_size, s_test_s3_calculate_client_optimal_range_size)
 static int s_test_s3_calculate_client_optimal_range_size(struct aws_allocator *allocator, void *ctx) {
     (void)ctx;
@@ -799,9 +808,9 @@ static int s_test_s3_calculate_client_optimal_range_size(struct aws_allocator *a
 
         /* Expected: 1GB / 10 / 3 = 34.13MB -> rounded up to alignment boundary */
         uint64_t memory_constrained = memory_limit / max_connections / 3;
-        uint64_t aligned_size =
-            ((memory_constrained / g_s3_optimal_range_size_alignment) + 1) * g_s3_optimal_range_size_alignment;
-        uint64_t expected = (aligned_size < g_default_part_size_fallback) ? g_default_part_size_fallback : aligned_size;
+        s_s3_range_size_alignment(&memory_constrained);
+        uint64_t expected =
+            (memory_constrained < g_default_part_size_fallback) ? g_default_part_size_fallback : memory_constrained;
         ASSERT_UINT_EQUALS(expected, client_optimal_range_size);
     }
 
@@ -841,9 +850,9 @@ static int s_test_s3_calculate_client_optimal_range_size(struct aws_allocator *a
 
         /* Expected: 300MB / 10 / 3 = 10MB -> rounded up to alignment boundary */
         uint64_t memory_constrained = memory_limit / max_connections / 3;
-        uint64_t aligned_size =
-            ((memory_constrained / g_s3_optimal_range_size_alignment) + 1) * g_s3_optimal_range_size_alignment;
-        uint64_t expected = (aligned_size < g_default_part_size_fallback) ? g_default_part_size_fallback : aligned_size;
+        s_s3_range_size_alignment(&memory_constrained);
+        uint64_t expected =
+            (memory_constrained < g_default_part_size_fallback) ? g_default_part_size_fallback : memory_constrained;
         ASSERT_UINT_EQUALS(expected, client_optimal_range_size);
     }
 
@@ -880,72 +889,73 @@ static int s_test_s3_calculate_request_optimal_range_size(struct aws_allocator *
 
     /* Test 1: Estimated part size is larger than client size - use client size */
     {
-        uint64_t client_optimal_range_size = g_s3_optimal_range_size_alignment * 5; /* 160 MB (5 * 32MB) */
-        uint64_t estimated_part_size = MB_TO_BYTES(200);                            /* 200 MB */
+        uint64_t client_optimal_range_size = MB_TO_BYTES(160); /* 160 MB (5 * 32MB) */
+        uint64_t estimated_part_size = MB_TO_BYTES(200);       /* 200 MB */
 
         ASSERT_SUCCESS(aws_s3_calculate_request_optimal_range_size(
             client_optimal_range_size, estimated_part_size, &request_optimal_range_size));
 
         /* Expected: min(160MB, 200MB) = 160MB */
-        uint64_t expected = g_s3_optimal_range_size_alignment * 5; /* 160 MB (5 * 32MB) */
+        uint64_t expected = client_optimal_range_size; /* 160 MB (5 * 32MB) */
+        s_s3_range_size_alignment(&expected);
         ASSERT_UINT_EQUALS(expected, request_optimal_range_size);
     }
 
     /* Test 2: Estimated part size is smaller than client size - use estimated size */
     {
-        uint64_t client_optimal_range_size = g_s3_optimal_range_size_alignment * 8; /* 64 MB (8 * 8MB) */
-        uint64_t estimated_part_size = MB_TO_BYTES(50);                             /* 50 MB */
+        uint64_t client_optimal_range_size = MB_TO_BYTES(64); /* 64 MB */
+        uint64_t estimated_part_size = MB_TO_BYTES(50);       /* 50 MB */
 
         ASSERT_SUCCESS(aws_s3_calculate_request_optimal_range_size(
             client_optimal_range_size, estimated_part_size, &request_optimal_range_size));
 
         /* Expected: min(64MB, 50MB) = 50MB -> rounded up to alignment boundary */
         uint64_t smaller_size = estimated_part_size; /* 50MB is smaller than 64MB */
-        uint64_t aligned_size =
-            ((smaller_size / g_s3_optimal_range_size_alignment) + 1) * g_s3_optimal_range_size_alignment;
-        uint64_t expected = (aligned_size < g_default_part_size_fallback) ? g_default_part_size_fallback : aligned_size;
+        s_s3_range_size_alignment(&smaller_size);
+        uint64_t expected = (smaller_size < g_default_part_size_fallback) ? g_default_part_size_fallback : smaller_size;
         ASSERT_UINT_EQUALS(expected, request_optimal_range_size);
     }
 
     /* Test 3: Estimated part size is very small - apply minimum constraint */
     {
-        uint64_t client_optimal_range_size = g_s3_optimal_range_size_alignment * 5; /* 160 MB (5 * 32MB) */
-        uint64_t estimated_part_size = MB_TO_BYTES(1);                              /* 1 MB */
+        uint64_t client_optimal_range_size = MB_TO_BYTES(160); /* 160 MB */
+        uint64_t estimated_part_size = MB_TO_BYTES(1);         /* 1 MB */
 
         ASSERT_SUCCESS(aws_s3_calculate_request_optimal_range_size(
             client_optimal_range_size, estimated_part_size, &request_optimal_range_size));
 
         /* Expected: min(160MB, 1MB) = minimum size (minimum constraint) */
         uint64_t expected = g_default_part_size_fallback; /* minimum size */
+        s_s3_range_size_alignment(&expected);
         ASSERT_UINT_EQUALS(expected, request_optimal_range_size);
     }
 
     /* Test 4: Zero estimated part size (unknown) - use client size */
     {
-        uint64_t client_optimal_range_size = g_s3_optimal_range_size_alignment * 5; /* 160 MB (5 * 32MB) */
-        uint64_t estimated_part_size = 0;                                           /* 0 - unknown */
+        uint64_t client_optimal_range_size = MB_TO_BYTES(160); /* 160 MB */
+        uint64_t estimated_part_size = 0;                      /* 0 - unknown */
 
         ASSERT_SUCCESS(aws_s3_calculate_request_optimal_range_size(
             client_optimal_range_size, estimated_part_size, &request_optimal_range_size));
 
         /* Expected: use client_optimal_range_size when estimated is unknown */
-        uint64_t expected = g_s3_optimal_range_size_alignment * 5; /* 160 MB (5 * 32MB) */
+        uint64_t expected = client_optimal_range_size; /* 160 MB (5 * 32MB) */
+        s_s3_range_size_alignment(&expected);
         ASSERT_UINT_EQUALS(expected, request_optimal_range_size);
     }
 
     /* Test 5: Alignment to buffer pool boundaries */
     {
-        uint64_t client_optimal_range_size = g_s3_optimal_range_size_alignment * 5; /* 40 MB (5 * 8MB) */
-        uint64_t estimated_part_size = MB_TO_BYTES(9);                              /* 9 MB */
+        uint64_t client_optimal_range_size = MB_TO_BYTES(40); /* 40 MB (5 * 8MB) */
+        uint64_t estimated_part_size = MB_TO_BYTES(9);        /* 9 MB */
 
         ASSERT_SUCCESS(aws_s3_calculate_request_optimal_range_size(
             client_optimal_range_size, estimated_part_size, &request_optimal_range_size));
 
         /* Expected: min(40MB, 9MB) = 9MB -> rounded up to alignment boundary */
         uint64_t smaller_size = estimated_part_size; /* 9MB is smaller than 40MB */
-        uint64_t aligned_size =
-            ((smaller_size / g_s3_optimal_range_size_alignment) + 1) * g_s3_optimal_range_size_alignment;
-        uint64_t expected = (aligned_size < g_default_part_size_fallback) ? g_default_part_size_fallback : aligned_size;
+        s_s3_range_size_alignment(&smaller_size);
+        uint64_t expected = (smaller_size < g_default_part_size_fallback) ? g_default_part_size_fallback : smaller_size;
         ASSERT_UINT_EQUALS(expected, request_optimal_range_size);
     }
 
