rename

Author: TingDaoK

include/aws/http/http2_stream_manager.h

@@ -160,11 +160,11 @@ struct aws_http2_stream_manager_options {
     size_t max_connections;
     /**
      * Optional.
-     * The max total number of streams that can be active across all connections at the same time.
+     * The max number of concurrent streams that can be active across all connections at the same time.
      * 0 means no limit (default). When this limit is reached, the stream manager will wait for
      * existing streams to complete before creating new ones, even if connections have available capacity.
      */
-    size_t max_total_streams;
+    size_t max_concurrent_streams;
 };
 
 struct aws_http2_stream_manager_acquire_stream_options {

include/aws/http/private/http2_stream_manager_impl.h

@@ -116,11 +116,11 @@ struct aws_http2_stream_manager {
 
     /**
      * Optional. 0 means no limit (default).
-     * The max total number of streams that can be active across all connections at the same time.
+     * The max number of concurrent streams that can be active across all connections at the same time.
      * When this limit is reached, the stream manager will wait for existing streams to complete
      * before creating new ones, even if connections have available capacity.
      */
-    size_t max_total_streams;
+    size_t max_concurrent_streams;
 
     /**
      * Task to invoke pending acquisition callbacks asynchronously if stream manager is shutting.

source/http2_stream_manager.c

@@ -152,20 +152,20 @@ static void s_sm_try_assign_connection_to_pending_stream_acquisition_synced(
 
     AWS_ASSERT(pending_stream_acquisition->sm_connection == NULL);
 
-    /* Check if we've reached the max_total_streams limit */
-    if (stream_manager->max_total_streams > 0) {
+    /* Check if we've reached the max_concurrent_streams limit */
+    if (stream_manager->max_concurrent_streams > 0) {
         size_t total_active_streams =
             stream_manager->synced_data.internal_refcount_stats[AWS_SMCT_OPEN_STREAM] +
             stream_manager->synced_data.internal_refcount_stats[AWS_SMCT_PENDING_MAKE_REQUESTS];
-        if (total_active_streams >= stream_manager->max_total_streams) {
+        if (total_active_streams >= stream_manager->max_concurrent_streams) {
             /* We've reached the limit, cannot assign a connection yet */
             STREAM_MANAGER_LOGF(
                 DEBUG,
                 stream_manager,
-                "acquisition:%p waiting - max_total_streams limit reached (%" PRIu64 "/%" PRIu64 ")",
+                "acquisition:%p waiting - max_concurrent_streams limit reached (%" PRIu64 "/%" PRIu64 ")",
                 (void *)pending_stream_acquisition,
                 (uint64_t)total_active_streams,
-                (uint64_t)stream_manager->max_total_streams);
+                (uint64_t)stream_manager->max_concurrent_streams);
             return;
         }
     }
@@ -1175,7 +1175,7 @@ struct aws_http2_stream_manager *aws_http2_stream_manager_new(
     stream_manager->max_concurrent_streams_per_connection =
         options->max_concurrent_streams_per_connection ? options->max_concurrent_streams_per_connection : UINT32_MAX;
     stream_manager->max_connections = options->max_connections;
-    stream_manager->max_total_streams = options->max_total_streams; /* 0 means no limit */
+    stream_manager->max_concurrent_streams = options->max_concurrent_streams; /* 0 means no limit */
     stream_manager->close_connection_on_server_error = options->close_connection_on_server_error;
 
     return stream_manager;

tests/CMakeLists.txt

@@ -694,9 +694,9 @@ add_net_test_case(h2_sm_mock_goaway)
 add_net_test_case(h2_sm_connection_ping)
 add_net_test_case(h2_sm_with_flow_control_err)
 add_net_test_case(h2_sm_with_initial_settings)
-add_net_test_case(h2_sm_mock_max_total_streams)
-add_net_test_case(h2_sm_mock_max_total_streams_multiple_connections)
-add_net_test_case(h2_sm_mock_max_total_streams_zero_means_no_limit)
+add_net_test_case(h2_sm_mock_max_concurrent_streams)
+add_net_test_case(h2_sm_mock_max_concurrent_streams_multiple_connections)
+add_net_test_case(h2_sm_mock_max_concurrent_streams_zero_means_no_limit)
 
 # Tests against real world server
 add_net_test_case(h2_sm_acquire_stream)

tests/test_stream_manager.c

@@ -1293,19 +1293,19 @@ TEST_CASE(h2_sm_with_initial_settings) {
     return s_tester_clean_up();
 }
 
-/* Test that max_total_streams limits the total number of active streams */
-TEST_CASE(h2_sm_mock_max_total_streams) {
+/* Test that max_concurrent_streams limits the total number of active streams */
+TEST_CASE(h2_sm_mock_max_concurrent_streams) {
     (void)ctx;
-    size_t max_total_streams = 5;
+    size_t max_concurrent_streams = 5;
     struct sm_tester_options options = {
         .max_connections = 3,
         .max_concurrent_streams_per_connection = 10,
         .alloc = allocator,
     };
     ASSERT_SUCCESS(s_tester_init(&options));
 
-    /* Set max_total_streams on the stream manager */
-    s_tester.stream_manager->max_total_streams = max_total_streams;
+    /* Set max_concurrent_streams on the stream manager */
+    s_tester.stream_manager->max_concurrent_streams = max_concurrent_streams;
 
     s_override_cm_connect_function(s_aws_http_connection_manager_create_connection_sync_mock);
 
@@ -1317,9 +1317,9 @@ TEST_CASE(h2_sm_mock_max_total_streams) {
     ASSERT_SUCCESS(s_wait_on_fake_connection_count(1));
     s_drain_all_fake_connection_testing_channel();
 
-    /* Should have acquired only max_total_streams streams */
-    ASSERT_SUCCESS(s_wait_on_streams_acquired_count(max_total_streams));
-    ASSERT_UINT_EQUALS(max_total_streams, aws_array_list_length(&s_tester.streams));
+    /* Should have acquired only max_concurrent_streams streams */
+    ASSERT_SUCCESS(s_wait_on_streams_acquired_count(max_concurrent_streams));
+    ASSERT_UINT_EQUALS(max_concurrent_streams, aws_array_list_length(&s_tester.streams));
 
     /* Complete 3 streams */
     struct sm_fake_connection *fake_connection = s_get_fake_connection(0);
@@ -1344,19 +1344,19 @@ TEST_CASE(h2_sm_mock_max_total_streams) {
     return s_tester_clean_up();
 }
 
-/* Test that max_total_streams works with multiple connections */
-TEST_CASE(h2_sm_mock_max_total_streams_multiple_connections) {
+/* Test that max_concurrent_streams works with multiple connections */
+TEST_CASE(h2_sm_mock_max_concurrent_streams_multiple_connections) {
     (void)ctx;
-    size_t max_total_streams = 8;
+    size_t max_concurrent_streams = 8;
     struct sm_tester_options options = {
         .max_connections = 4,
         .max_concurrent_streams_per_connection = 3,
         .alloc = allocator,
     };
     ASSERT_SUCCESS(s_tester_init(&options));
 
-    /* Set max_total_streams */
-    s_tester.stream_manager->max_total_streams = max_total_streams;
+    /* Set max_concurrent_streams */
+    s_tester.stream_manager->max_concurrent_streams = max_concurrent_streams;
 
     s_override_cm_connect_function(s_aws_http_connection_manager_create_connection_sync_mock);
 
@@ -1368,9 +1368,9 @@ TEST_CASE(h2_sm_mock_max_total_streams_multiple_connections) {
     ASSERT_SUCCESS(s_wait_on_fake_connection_count(4));
     s_drain_all_fake_connection_testing_channel();
 
-    /* Should have acquired only max_total_streams streams */
-    ASSERT_SUCCESS(s_wait_on_streams_acquired_count(max_total_streams));
-    ASSERT_UINT_EQUALS(max_total_streams, aws_array_list_length(&s_tester.streams));
+    /* Should have acquired only max_concurrent_streams streams */
+    ASSERT_SUCCESS(s_wait_on_streams_acquired_count(max_concurrent_streams));
+    ASSERT_UINT_EQUALS(max_concurrent_streams, aws_array_list_length(&s_tester.streams));
     /* 4 connections total */
     ASSERT_UINT_EQUALS(4, aws_array_list_length(&s_tester.fake_connections));
 
@@ -1398,8 +1398,8 @@ TEST_CASE(h2_sm_mock_max_total_streams_multiple_connections) {
     return s_tester_clean_up();
 }
 
-/* Test that max_total_streams = 0 means no limit (default behavior) */
-TEST_CASE(h2_sm_mock_max_total_streams_zero_means_no_limit) {
+/* Test that max_concurrent_streams = 0 means no limit (default behavior) */
+TEST_CASE(h2_sm_mock_max_concurrent_streams_zero_means_no_limit) {
     (void)ctx;
     struct sm_tester_options options = {
         .max_connections = 2,
@@ -1408,8 +1408,8 @@ TEST_CASE(h2_sm_mock_max_total_streams_zero_means_no_limit) {
     };
     ASSERT_SUCCESS(s_tester_init(&options));
 
-    /* max_total_streams defaults to 0 (no limit) */
-    ASSERT_UINT_EQUALS(0, s_tester.stream_manager->max_total_streams);
+    /* max_concurrent_streams defaults to 0 (no limit) */
+    ASSERT_UINT_EQUALS(0, s_tester.stream_manager->max_concurrent_streams);
 
     s_override_cm_connect_function(s_aws_http_connection_manager_create_connection_sync_mock);