Skip to content
Projects
Groups
Snippets
Help
Loading...
Help
Support
Keyboard shortcuts
?
Submit feedback
Contribute to GitLab
Sign in / Register
Toggle navigation
L
libnice
Project overview
Project overview
Details
Activity
Releases
Repository
Repository
Files
Commits
Branches
Tags
Contributors
Graph
Compare
Issues
0
Issues
0
List
Boards
Labels
Milestones
Merge Requests
0
Merge Requests
0
CI / CD
CI / CD
Pipelines
Jobs
Schedules
Analytics
Analytics
CI / CD
Repository
Value Stream
Wiki
Wiki
Snippets
Snippets
Members
Members
Collapse sidebar
Close sidebar
Activity
Graph
Create a new issue
Jobs
Commits
Issue Boards
Open sidebar
cpp-libs
libnice
Commits
905aa839
Commit
905aa839
authored
Jan 16, 2014
by
Philip Withnall
Committed by
Olivier Crête
Jan 31, 2014
Browse files
Options
Browse Files
Download
Email Patches
Plain Diff
tests: Update test-send-recv to support vectored I/O
parent
253be348
Changes
1
Show whitespace changes
Inline
Side-by-side
Showing
1 changed file
with
338 additions
and
94 deletions
+338
-94
tests/test-send-recv.c
tests/test-send-recv.c
+338
-94
No files found.
tests/test-send-recv.c
View file @
905aa839
...
@@ -81,6 +81,20 @@ typedef enum {
...
@@ -81,6 +81,20 @@ typedef enum {
}
BufferSizeStrategy
;
}
BufferSizeStrategy
;
#define BUFFER_SIZE_STRATEGY_N_ELEMENTS (BUFFER_SIZE_RANDOM + 1)
#define BUFFER_SIZE_STRATEGY_N_ELEMENTS (BUFFER_SIZE_RANDOM + 1)
typedef
enum
{
BUFFER_COUNT_CONSTANT_ONE
,
/* always a single buffer */
BUFFER_COUNT_CONSTANT_TWO
,
/* always two buffers */
BUFFER_COUNT_RANDOM
,
/* random every time */
}
BufferCountStrategy
;
#define BUFFER_COUNT_STRATEGY_N_ELEMENTS (BUFFER_COUNT_RANDOM + 1)
typedef
enum
{
MESSAGE_COUNT_CONSTANT_ONE
,
/* always a single message */
MESSAGE_COUNT_CONSTANT_TWO
,
/* always two messages */
MESSAGE_COUNT_RANDOM
,
/* random every time */
}
MessageCountStrategy
;
#define MESSAGE_COUNT_STRATEGY_N_ELEMENTS (MESSAGE_COUNT_RANDOM + 1)
typedef
enum
{
typedef
enum
{
BUFFER_DATA_CONSTANT
,
/* fill with 0xfe */
BUFFER_DATA_CONSTANT
,
/* fill with 0xfe */
BUFFER_DATA_ASCENDING
,
/* ascending values for each byte */
BUFFER_DATA_ASCENDING
,
/* ascending values for each byte */
...
@@ -92,8 +106,16 @@ typedef struct {
...
@@ -92,8 +106,16 @@ typedef struct {
/* Test configuration (immutable per test run). */
/* Test configuration (immutable per test run). */
gboolean
reliable
;
gboolean
reliable
;
StreamApi
stream_api
;
StreamApi
stream_api
;
BufferSizeStrategy
transmit_buffer_size_strategy
;
struct
{
BufferSizeStrategy
receive_buffer_size_strategy
;
BufferSizeStrategy
buffer_size_strategy
;
BufferCountStrategy
buffer_count_strategy
;
MessageCountStrategy
message_count_strategy
;
}
transmit
;
struct
{
BufferSizeStrategy
buffer_size_strategy
;
BufferCountStrategy
buffer_count_strategy
;
MessageCountStrategy
message_count_strategy
;
}
receive
;
BufferDataStrategy
buffer_data_strategy
;
BufferDataStrategy
buffer_data_strategy
;
gsize
n_bytes
;
gsize
n_bytes
;
...
@@ -137,11 +159,28 @@ stream_api_is_reliable_only (StreamApi stream_api)
...
@@ -137,11 +159,28 @@ stream_api_is_reliable_only (StreamApi stream_api)
}
}
}
}
/* Generate a size for the @buffer_index-th buffer. Guaranteed to be in
/* Whether @stream_api supports vectored I/O (multiple buffers or messages). */
* the interval [1, 1 << 16). ((1 << 16) is the maximum message size.) */
static
gboolean
stream_api_supports_vectored_io
(
StreamApi
stream_api
)
{
switch
(
stream_api
)
{
case
STREAM_AGENT
:
case
STREAM_AGENT_NONBLOCKING
:
return
TRUE
;
case
STREAM_GSOURCE
:
case
STREAM_GIO
:
return
FALSE
;
default:
g_assert_not_reached
();
}
}
/* Generate a size for the buffer containing the @buffer_offset-th byte.
* Guaranteed to be in the interval [1, 1 << 16). ((1 << 16) is the maximum
* message size.) */
static
gsize
static
gsize
generate_buffer_size
(
BufferSizeStrategy
strategy
,
GRand
*
rand
,
generate_buffer_size
(
BufferSizeStrategy
strategy
,
GRand
*
rand
,
g
uint
buffer_index
)
g
size
buffer_offset
)
{
{
switch
(
strategy
)
{
switch
(
strategy
)
{
case
BUFFER_SIZE_CONSTANT_LARGE
:
case
BUFFER_SIZE_CONSTANT_LARGE
:
...
@@ -154,7 +193,7 @@ generate_buffer_size (BufferSizeStrategy strategy, GRand *rand,
...
@@ -154,7 +193,7 @@ generate_buffer_size (BufferSizeStrategy strategy, GRand *rand,
return
1
;
return
1
;
case
BUFFER_SIZE_ASCENDING
:
case
BUFFER_SIZE_ASCENDING
:
return
CLAMP
(
1L
<<
buffer_
index
,
1
,
(
1
<<
16
)
-
1
);
return
CLAMP
(
1L
<<
buffer_
offset
,
1
,
(
1
<<
16
)
-
1
);
case
BUFFER_SIZE_RANDOM
:
case
BUFFER_SIZE_RANDOM
:
return
g_rand_int_range
(
rand
,
1
,
1
<<
16
);
return
g_rand_int_range
(
rand
,
1
,
1
<<
16
);
...
@@ -164,6 +203,50 @@ generate_buffer_size (BufferSizeStrategy strategy, GRand *rand,
...
@@ -164,6 +203,50 @@ generate_buffer_size (BufferSizeStrategy strategy, GRand *rand,
}
}
}
}
/* Generate a number of buffers to allocate when receiving the @buffer_offset-th
* byte. Guaranteed to be in the interval [1, 100], where 100 was chosen
* arbitrarily.*/
static
guint
generate_buffer_count
(
BufferCountStrategy
strategy
,
GRand
*
rand
,
gsize
buffer_offset
)
{
switch
(
strategy
)
{
case
BUFFER_COUNT_CONSTANT_ONE
:
return
1
;
case
BUFFER_COUNT_CONSTANT_TWO
:
return
2
;
case
BUFFER_COUNT_RANDOM
:
return
g_rand_int_range
(
rand
,
1
,
100
+
1
);
default:
g_assert_not_reached
();
}
}
/* Generate a number of messages to allocate and receive into when receiving the
* @buffer_offset-th byte. Guaranteed to be in the interval [1, 100], where 100
* was chosen arbitrarily.*/
static
guint
generate_message_count
(
MessageCountStrategy
strategy
,
GRand
*
rand
,
guint
buffer_index
)
{
switch
(
strategy
)
{
case
MESSAGE_COUNT_CONSTANT_ONE
:
return
1
;
case
MESSAGE_COUNT_CONSTANT_TWO
:
return
2
;
case
MESSAGE_COUNT_RANDOM
:
return
g_rand_int_range
(
rand
,
1
,
100
+
1
);
default:
g_assert_not_reached
();
}
}
/* Fill the given @buf with @buf_len bytes of generated data. The data is
/* Fill the given @buf with @buf_len bytes of generated data. The data is
* deterministically generated, so that:
* deterministically generated, so that:
* generate_buffer_data(_, I, buf, 2)
* generate_buffer_data(_, I, buf, 2)
...
@@ -231,7 +314,7 @@ generate_buffer_to_receive (TestIOStreamThreadData *data, gsize buffer_offset,
...
@@ -231,7 +314,7 @@ generate_buffer_to_receive (TestIOStreamThreadData *data, gsize buffer_offset,
TestData
*
test_data
=
data
->
user_data
;
TestData
*
test_data
=
data
->
user_data
;
/* Allocate the buffer. */
/* Allocate the buffer. */
*
buf_len
=
generate_buffer_size
(
test_data
->
receive
_
buffer_size_strategy
,
*
buf_len
=
generate_buffer_size
(
test_data
->
receive
.
buffer_size_strategy
,
test_data
->
receive_size_rand
,
buffer_offset
);
test_data
->
receive_size_rand
,
buffer_offset
);
*
buf
=
g_malloc
(
*
buf_len
);
*
buf
=
g_malloc
(
*
buf_len
);
...
@@ -239,6 +322,70 @@ generate_buffer_to_receive (TestIOStreamThreadData *data, gsize buffer_offset,
...
@@ -239,6 +322,70 @@ generate_buffer_to_receive (TestIOStreamThreadData *data, gsize buffer_offset,
memset
(
*
buf
,
0xaa
,
*
buf_len
);
memset
(
*
buf
,
0xaa
,
*
buf_len
);
}
}
/* Similar to generate_buffer_to_receive(), but generate an entire message array
* with multiple buffers instead.
*
* @max_buffer_size may be used to limit the total size of all the buffers in
* all the messages, for example to avoid blocking on receiving data which will
* never be sent.
*
* @messages must be freed with g_free(), as must all of the buffer arrays and
* the buffers themselves. */
static
void
generate_messages_to_receive
(
TestIOStreamThreadData
*
data
,
gsize
buffer_offset
,
NiceInputMessage
**
messages
,
guint
*
n_messages
,
gsize
max_buffer_size
)
{
TestData
*
test_data
=
data
->
user_data
;
guint
i
;
/* Allocate the messages. */
*
n_messages
=
generate_message_count
(
test_data
->
receive
.
message_count_strategy
,
test_data
->
receive_size_rand
,
buffer_offset
);
*
messages
=
g_malloc_n
(
*
n_messages
,
sizeof
(
NiceInputMessage
));
for
(
i
=
0
;
i
<
*
n_messages
;
i
++
)
{
NiceInputMessage
*
message
=
&
((
*
messages
)[
i
]);
guint
j
;
message
->
n_buffers
=
generate_buffer_count
(
test_data
->
receive
.
buffer_count_strategy
,
test_data
->
receive_size_rand
,
buffer_offset
);
message
->
buffers
=
g_malloc_n
(
message
->
n_buffers
,
sizeof
(
GInputVector
));
message
->
from
=
NULL
;
message
->
length
=
0
;
for
(
j
=
0
;
j
<
(
guint
)
message
->
n_buffers
;
j
++
)
{
GInputVector
*
buffer
=
&
message
->
buffers
[
j
];
gsize
buf_len
;
buf_len
=
generate_buffer_size
(
test_data
->
receive
.
buffer_size_strategy
,
test_data
->
receive_size_rand
,
buffer_offset
);
/* Trim the buffer length if it would otherwise cause the API to block. */
if
(
data
->
reliable
)
buf_len
=
MIN
(
buf_len
,
max_buffer_size
);
max_buffer_size
-=
buf_len
;
buffer
->
size
=
buf_len
;
buffer
->
buffer
=
g_malloc
(
buffer
->
size
);
/* Fill it with poison to try and detect incorrect writes. */
memset
(
buffer
->
buffer
,
0xaa
,
buffer
->
size
);
/* If we’ve hit the max_buffer_size, adjust the buffer and message counts
* and run away. */
if
(
max_buffer_size
==
0
)
{
message
->
n_buffers
=
j
+
1
;
*
n_messages
=
i
+
1
;
return
;
}
}
}
}
/* Validate the length and data of a received buffer of length @buf_len, filled
/* Validate the length and data of a received buffer of length @buf_len, filled
* with @len valid bytes. Updates the internal state machine to mark the bytes
* with @len valid bytes. Updates the internal state machine to mark the bytes
* as received. This consumes @buf. */
* as received. This consumes @buf. */
...
@@ -268,6 +415,73 @@ validate_received_buffer (TestIOStreamThreadData *data, gsize buffer_offset,
...
@@ -268,6 +415,73 @@ validate_received_buffer (TestIOStreamThreadData *data, gsize buffer_offset,
g_free
(
*
buf
);
g_free
(
*
buf
);
}
}
/* Similar to validate_received_buffer(), except it validates a message array
* instead of a single buffer. This consumes @messages. */
static
void
validate_received_messages
(
TestIOStreamThreadData
*
data
,
gsize
buffer_offset
,
NiceInputMessage
**
messages
,
guint
n_messages
,
gint
n_valid_messages
)
{
TestData
*
test_data
=
data
->
user_data
;
guint
i
;
gsize
prev_message_len
=
G_MAXSIZE
;
g_assert_cmpint
(
n_valid_messages
,
<=
,
n_messages
);
g_assert_cmpint
(
n_valid_messages
,
>=
,
0
);
if
(
stream_api_is_blocking
(
test_data
->
stream_api
))
g_assert_cmpint
(
n_valid_messages
,
==
,
n_messages
);
/* Validate the message contents. */
for
(
i
=
0
;
i
<
(
guint
)
n_valid_messages
;
i
++
)
{
NiceInputMessage
*
message
=
&
((
*
messages
)[
i
]);
guint
j
;
gsize
total_buf_len
=
0
;
gsize
message_len_remaining
=
message
->
length
;
g_assert_cmpint
(
message
->
n_buffers
,
>
,
0
);
for
(
j
=
0
;
j
<
(
guint
)
message
->
n_buffers
;
j
++
)
{
GInputVector
*
buffer
=
&
message
->
buffers
[
j
];
guint8
*
expected_buf
;
gsize
valid_len
;
total_buf_len
+=
buffer
->
size
;
valid_len
=
MIN
(
message_len_remaining
,
buffer
->
size
);
expected_buf
=
g_malloc
(
buffer
->
size
);
memset
(
expected_buf
,
0xaa
,
buffer
->
size
);
generate_buffer_data
(
test_data
->
buffer_data_strategy
,
buffer_offset
,
expected_buf
,
valid_len
);
g_assert
(
memcmp
(
buffer
->
buffer
,
expected_buf
,
buffer
->
size
)
==
0
);
g_free
(
expected_buf
);
test_data
->
received_bytes
+=
valid_len
;
buffer_offset
+=
valid_len
;
message_len_remaining
-=
valid_len
;
g_free
(
buffer
->
buffer
);
}
g_assert_cmpuint
(
message
->
length
,
<=
,
total_buf_len
);
g_assert_cmpuint
(
message
->
length
,
>=
,
0
);
/* No non-empty messages can follow an empty message. */
if
(
prev_message_len
==
0
)
g_assert_cmpuint
(
message
->
length
,
==
,
0
);
prev_message_len
=
message
->
length
;
/* If the API was blocking, it should have completely filled the message. */
if
(
stream_api_is_blocking
(
test_data
->
stream_api
))
g_assert_cmpuint
(
message
->
length
,
==
,
total_buf_len
);
g_assert
(
message
->
from
==
NULL
);
g_free
(
message
->
buffers
);
}
g_free
(
*
messages
);
}
/* Determine a size for the next transmit buffer, allocate it, and fill it with
/* Determine a size for the next transmit buffer, allocate it, and fill it with
* data to be transmitted. */
* data to be transmitted. */
static
void
static
void
...
@@ -277,7 +491,7 @@ generate_buffer_to_transmit (TestIOStreamThreadData *data, gsize buffer_offset,
...
@@ -277,7 +491,7 @@ generate_buffer_to_transmit (TestIOStreamThreadData *data, gsize buffer_offset,
TestData
*
test_data
=
data
->
user_data
;
TestData
*
test_data
=
data
->
user_data
;
/* Allocate the buffer. */
/* Allocate the buffer. */
*
buf_len
=
generate_buffer_size
(
test_data
->
transmit
_
buffer_size_strategy
,
*
buf_len
=
generate_buffer_size
(
test_data
->
transmit
.
buffer_size_strategy
,
test_data
->
transmit_size_rand
,
buffer_offset
);
test_data
->
transmit_size_rand
,
buffer_offset
);
*
buf_len
=
MIN
(
*
buf_len
,
test_data
->
n_bytes
-
test_data
->
transmitted_bytes
);
*
buf_len
=
MIN
(
*
buf_len
,
test_data
->
n_bytes
-
test_data
->
transmitted_bytes
);
*
buf
=
g_malloc
(
*
buf_len
);
*
buf
=
g_malloc
(
*
buf_len
);
...
@@ -304,7 +518,7 @@ notify_transmitted_buffer (TestIOStreamThreadData *data, gsize buffer_offset,
...
@@ -304,7 +518,7 @@ notify_transmitted_buffer (TestIOStreamThreadData *data, gsize buffer_offset,
}
}
/*
/*
* Implementation using nice_agent_recv() and nice_agent_send().
* Implementation using nice_agent_recv
_messages
() and nice_agent_send().
*/
*/
static
void
static
void
read_thread_agent_cb
(
GInputStream
*
input_stream
,
TestIOStreamThreadData
*
data
)
read_thread_agent_cb
(
GInputStream
*
input_stream
,
TestIOStreamThreadData
*
data
)
...
@@ -319,27 +533,22 @@ read_thread_agent_cb (GInputStream *input_stream, TestIOStreamThreadData *data)
...
@@ -319,27 +533,22 @@ read_thread_agent_cb (GInputStream *input_stream, TestIOStreamThreadData *data)
while
(
test_data
->
received_bytes
<
test_data
->
n_bytes
)
{
while
(
test_data
->
received_bytes
<
test_data
->
n_bytes
)
{
GError
*
error
=
NULL
;
GError
*
error
=
NULL
;
guint8
*
buf
=
NULL
;
NiceInputMessage
*
messages
;
gsize
buf_len
=
0
;
guint
n_messages
;
gssize
len
;
gint
n_valid_messages
;
/* Initialise a receive buffer. */
generate_buffer_to_receive
(
data
,
test_data
->
received_bytes
,
&
buf
,
&
buf_len
);
/* Trim the receive buffer to avoid blocking on bytes which will never
/* Initialise an array of messages to receive into. */
* appear. */
generate_messages_to_receive
(
data
,
test_data
->
received_bytes
,
&
messages
,
if
(
data
->
reliable
)
&
n_messages
,
test_data
->
n_bytes
-
test_data
->
received_bytes
);
buf_len
=
MIN
(
buf_len
,
test_data
->
n_bytes
-
test_data
->
received_bytes
);
/* Block on receiving some data. */
/* Block on receiving some data. */
len
=
nice_agent_recv
(
data
->
agent
,
stream_id
,
component_id
,
buf
,
buf_len
,
n_valid_messages
=
nice_agent_recv_messages
(
data
->
agent
,
stream_id
,
NULL
,
&
error
);
component_id
,
messages
,
n_messages
,
NULL
,
&
error
);
g_assert_no_error
(
error
);
g_assert_no_error
(
error
);
/* Check the
buffer
and update the test’s state machine. */
/* Check the
messages
and update the test’s state machine. */
validate_received_
buffer
(
data
,
test_data
->
received_bytes
,
&
buf
,
buf_len
,
validate_received_
messages
(
data
,
test_data
->
received_bytes
,
&
messages
,
len
);
n_messages
,
n_valid_messages
);
}
}
check_for_termination
(
data
,
&
test_data
->
received_bytes
,
check_for_termination
(
data
,
&
test_data
->
received_bytes
,
...
@@ -413,30 +622,26 @@ read_thread_agent_nonblocking_cb (GInputStream *input_stream,
...
@@ -413,30 +622,26 @@ read_thread_agent_nonblocking_cb (GInputStream *input_stream,
while
(
test_data
->
received_bytes
<
test_data
->
n_bytes
)
{
while
(
test_data
->
received_bytes
<
test_data
->
n_bytes
)
{
GError
*
error
=
NULL
;
GError
*
error
=
NULL
;
guint8
*
buf
=
NULL
;
NiceInputMessage
*
messages
;
gsize
buf_len
=
0
;
guint
n_messages
;
gssize
len
;
gint
n_valid_messages
;
/* Initialise a receive buffer. */
generate_buffer_to_receive
(
data
,
test_data
->
received_bytes
,
&
buf
,
&
buf_len
);
/*
Trim the receive buffer to avoid consuming the ‘done’ message
. */
/*
Initialise an array of messages to receive into
. */
if
(
data
->
reliable
)
generate_messages_to_receive
(
data
,
test_data
->
received_bytes
,
&
messages
,
buf_len
=
MIN
(
buf_len
,
test_data
->
n_bytes
-
test_data
->
received_bytes
);
&
n_messages
,
test_data
->
n_bytes
-
test_data
->
received_bytes
);
/* Busy loop on receiving some data. */
/* Busy loop on receiving some data. */
do
{
do
{
g_clear_error
(
&
error
);
g_clear_error
(
&
error
);
len
=
nice_agent_recv_nonblocking
(
data
->
agent
,
stream_id
,
component_id
,
n_valid_messages
=
nice_agent_recv_messages_nonblocking
(
data
->
agent
,
buf
,
buf_len
,
NULL
,
&
error
);
stream_id
,
component_id
,
messages
,
n_messages
,
NULL
,
&
error
);
}
while
(
len
==
-
1
&&
}
while
(
n_valid_messages
==
-
1
&&
g_error_matches
(
error
,
G_IO_ERROR
,
G_IO_ERROR_WOULD_BLOCK
));
g_error_matches
(
error
,
G_IO_ERROR
,
G_IO_ERROR_WOULD_BLOCK
));
g_assert_no_error
(
error
);
g_assert_no_error
(
error
);
/* Check the
buffer
and update the test’s state machine. */
/* Check the
messages
and update the test’s state machine. */
validate_received_
buffer
(
data
,
test_data
->
received_bytes
,
&
buf
,
buf_len
,
validate_received_
messages
(
data
,
test_data
->
received_bytes
,
&
messages
,
len
);
n_messages
,
n_valid_messages
);
}
}
check_for_termination
(
data
,
&
test_data
->
received_bytes
,
check_for_termination
(
data
,
&
test_data
->
received_bytes
,
...
@@ -685,15 +890,23 @@ write_thread_gsource_cb (GOutputStream *output_stream,
...
@@ -685,15 +890,23 @@ write_thread_gsource_cb (GOutputStream *output_stream,
static
void
static
void
test_data_init
(
TestData
*
data
,
gboolean
reliable
,
StreamApi
stream_api
,
test_data_init
(
TestData
*
data
,
gboolean
reliable
,
StreamApi
stream_api
,
gsize
n_bytes
,
BufferSizeStrategy
transmit_buffer_size_strategy
,
gsize
n_bytes
,
BufferSizeStrategy
transmit_buffer_size_strategy
,
BufferCountStrategy
transmit_buffer_count_strategy
,
MessageCountStrategy
transmit_message_count_strategy
,
BufferSizeStrategy
receive_buffer_size_strategy
,
BufferSizeStrategy
receive_buffer_size_strategy
,
BufferCountStrategy
receive_buffer_count_strategy
,
MessageCountStrategy
receive_message_count_strategy
,
BufferDataStrategy
buffer_data_strategy
,
guint32
transmit_seed
,
BufferDataStrategy
buffer_data_strategy
,
guint32
transmit_seed
,
guint32
receive_seed
,
gsize
*
other_received_bytes
)
guint32
receive_seed
,
gsize
*
other_received_bytes
)
{
{
data
->
reliable
=
reliable
;
data
->
reliable
=
reliable
;
data
->
stream_api
=
stream_api
;
data
->
stream_api
=
stream_api
;
data
->
n_bytes
=
n_bytes
;
data
->
n_bytes
=
n_bytes
;
data
->
transmit_buffer_size_strategy
=
transmit_buffer_size_strategy
;
data
->
transmit
.
buffer_size_strategy
=
transmit_buffer_size_strategy
;
data
->
receive_buffer_size_strategy
=
receive_buffer_size_strategy
;
data
->
transmit
.
buffer_count_strategy
=
transmit_buffer_count_strategy
;
data
->
transmit
.
message_count_strategy
=
transmit_message_count_strategy
;
data
->
receive
.
buffer_size_strategy
=
receive_buffer_size_strategy
;
data
->
receive
.
buffer_count_strategy
=
receive_buffer_count_strategy
;
data
->
receive
.
message_count_strategy
=
receive_message_count_strategy
;
data
->
buffer_data_strategy
=
buffer_data_strategy
;
data
->
buffer_data_strategy
=
buffer_data_strategy
;
data
->
transmit_size_rand
=
g_rand_new_with_seed
(
transmit_seed
);
data
->
transmit_size_rand
=
g_rand_new_with_seed
(
transmit_seed
);
data
->
receive_size_rand
=
g_rand_new_with_seed
(
receive_seed
);
data
->
receive_size_rand
=
g_rand_new_with_seed
(
receive_seed
);
...
@@ -715,7 +928,11 @@ test_data_clear (TestData *data)
...
@@ -715,7 +928,11 @@ test_data_clear (TestData *data)
static
void
static
void
test
(
gboolean
reliable
,
StreamApi
stream_api
,
gsize
n_bytes
,
test
(
gboolean
reliable
,
StreamApi
stream_api
,
gsize
n_bytes
,
BufferSizeStrategy
transmit_buffer_size_strategy
,
BufferSizeStrategy
transmit_buffer_size_strategy
,
BufferCountStrategy
transmit_buffer_count_strategy
,
MessageCountStrategy
transmit_message_count_strategy
,
BufferSizeStrategy
receive_buffer_size_strategy
,
BufferSizeStrategy
receive_buffer_size_strategy
,
BufferCountStrategy
receive_buffer_count_strategy
,
MessageCountStrategy
receive_message_count_strategy
,
BufferDataStrategy
buffer_data_strategy
,
BufferDataStrategy
buffer_data_strategy
,
guint32
transmit_seed
,
guint32
receive_seed
,
guint32
transmit_seed
,
guint32
receive_seed
,
guint
deadlock_timeout
)
guint
deadlock_timeout
)
...
@@ -734,11 +951,15 @@ test (gboolean reliable, StreamApi stream_api, gsize n_bytes,
...
@@ -734,11 +951,15 @@ test (gboolean reliable, StreamApi stream_api, gsize n_bytes,
};
};
test_data_init
(
&
l_data
,
reliable
,
stream_api
,
n_bytes
,
test_data_init
(
&
l_data
,
reliable
,
stream_api
,
n_bytes
,
transmit_buffer_size_strategy
,
receive_buffer_size_strategy
,
transmit_buffer_size_strategy
,
transmit_buffer_count_strategy
,
transmit_message_count_strategy
,
receive_buffer_size_strategy
,
receive_buffer_count_strategy
,
receive_message_count_strategy
,
buffer_data_strategy
,
transmit_seed
,
receive_seed
,
buffer_data_strategy
,
transmit_seed
,
receive_seed
,
&
r_data
.
received_bytes
);
&
r_data
.
received_bytes
);
test_data_init
(
&
r_data
,
reliable
,
stream_api
,
n_bytes
,
test_data_init
(
&
r_data
,
reliable
,
stream_api
,
n_bytes
,
transmit_buffer_size_strategy
,
receive_buffer_size_strategy
,
transmit_buffer_size_strategy
,
transmit_buffer_count_strategy
,
transmit_message_count_strategy
,
receive_buffer_size_strategy
,
receive_buffer_count_strategy
,
receive_message_count_strategy
,
buffer_data_strategy
,
transmit_seed
,
receive_seed
,
buffer_data_strategy
,
transmit_seed
,
receive_seed
,
&
l_data
.
received_bytes
);
&
l_data
.
received_bytes
);
...
@@ -776,7 +997,11 @@ main (int argc, char *argv[])
...
@@ -776,7 +997,11 @@ main (int argc, char *argv[])
gboolean
reliable
;
gboolean
reliable
;
StreamApi
stream_api
;
StreamApi
stream_api
;
BufferSizeStrategy
transmit_buffer_size_strategy
;
BufferSizeStrategy
transmit_buffer_size_strategy
;
BufferCountStrategy
transmit_buffer_count_strategy
;
MessageCountStrategy
transmit_message_count_strategy
;
BufferSizeStrategy
receive_buffer_size_strategy
;
BufferSizeStrategy
receive_buffer_size_strategy
;
BufferCountStrategy
receive_buffer_count_strategy
;
MessageCountStrategy
receive_message_count_strategy
;
BufferDataStrategy
buffer_data_strategy
;
BufferDataStrategy
buffer_data_strategy
;
guint32
transmit_seed
;
guint32
transmit_seed
;
guint32
receive_seed
;
guint32
receive_seed
;
...
@@ -836,33 +1061,43 @@ main (int argc, char *argv[])
...
@@ -836,33 +1061,43 @@ main (int argc, char *argv[])
transmit_buffer_size_strategy
=
BUFFER_SIZE_RANDOM
;
transmit_buffer_size_strategy
=
BUFFER_SIZE_RANDOM
;
buffer_data_strategy
=
BUFFER_DATA_PSEUDO_RANDOM
;
buffer_data_strategy
=
BUFFER_DATA_PSEUDO_RANDOM
;
if
(
stream_api_supports_vectored_io
(
stream_api
))
{
transmit_buffer_count_strategy
=
BUFFER_COUNT_RANDOM
;
transmit_message_count_strategy
=
MESSAGE_COUNT_RANDOM
;
receive_buffer_count_strategy
=
BUFFER_COUNT_RANDOM
;
receive_message_count_strategy
=
MESSAGE_COUNT_RANDOM
;
}
else
{
transmit_buffer_count_strategy
=
BUFFER_COUNT_CONSTANT_ONE
;
transmit_message_count_strategy
=
MESSAGE_COUNT_CONSTANT_ONE
;
receive_buffer_count_strategy
=
BUFFER_COUNT_CONSTANT_ONE
;
receive_message_count_strategy
=
MESSAGE_COUNT_CONSTANT_ONE
;
}
g_debug
(
"Running test (%u, %u, %"
G_GSIZE_FORMAT
", %u, "
g_debug
(
"Running test (%u, %u, %"
G_GSIZE_FORMAT
", %u, "
"%u, %u, %u, %u)…"
,
"%u, %u, %u, %u)…"
,
reliable
,
stream_api
,
n_bytes
,
transmit_buffer_size_strategy
,
reliable
,
stream_api
,
n_bytes
,
transmit_buffer_size_strategy
,
receive_buffer_size_strategy
,
buffer_data_strategy
,
receive_buffer_size_strategy
,
buffer_data_strategy
,
transmit_seed
,
receive_seed
);
transmit_seed
,
receive_seed
);
test
(
reliable
,
stream_api
,
n_bytes
,
transmit_buffer_size_strategy
,
test
(
reliable
,
stream_api
,
n_bytes
,
transmit_buffer_size_strategy
,
receive_buffer_size_strategy
,
buffer_data_strategy
,
transmit_buffer_count_strategy
,
transmit_message_count_strategy
,
receive_buffer_size_strategy
,
receive_buffer_count_strategy
,
receive_message_count_strategy
,
buffer_data_strategy
,
transmit_seed
,
receive_seed
,
transmit_seed
,
receive_seed
,
deadlock_timeout
/
20
/* arbitrary reduction */
);
deadlock_timeout
);
}
}
}
}
goto
done
;
goto
done
;
}
}
/* Transmit buffer strategy. */
#define STRATEGY_LOOP(V, L) for (V = 0; (guint) V < L##_N_ELEMENTS; V++)
for
(
transmit_buffer_size_strategy
=
0
;
STRATEGY_LOOP
(
transmit_buffer_size_strategy
,
BUFFER_SIZE_STRATEGY
)
(
guint
)
transmit_buffer_size_strategy
<
BUFFER_SIZE_STRATEGY_N_ELEMENTS
;
STRATEGY_LOOP
(
transmit_buffer_count_strategy
,
BUFFER_COUNT_STRATEGY
)
transmit_buffer_size_strategy
++
)
{
STRATEGY_LOOP
(
transmit_message_count_strategy
,
MESSAGE_COUNT_STRATEGY
)
/* Receive buffer strategy. */
STRATEGY_LOOP
(
receive_buffer_size_strategy
,
BUFFER_SIZE_STRATEGY
)
for
(
receive_buffer_size_strategy
=
0
;
STRATEGY_LOOP
(
receive_buffer_count_strategy
,
BUFFER_COUNT_STRATEGY
)
(
guint
)
receive_buffer_size_strategy
<
BUFFER_SIZE_STRATEGY_N_ELEMENTS
;
STRATEGY_LOOP
(
receive_message_count_strategy
,
MESSAGE_COUNT_STRATEGY
)
receive_buffer_size_strategy
++
)
{
STRATEGY_LOOP
(
buffer_data_strategy
,
BUFFER_DATA_STRATEGY
)
/* Transmit data strategy. */
for
(
buffer_data_strategy
=
0
;
(
guint
)
buffer_data_strategy
<
BUFFER_DATA_STRATEGY_N_ELEMENTS
;
buffer_data_strategy
++
)
{
/* Reliability. */
/* Reliability. */
for
(
reliable
=
0
;
reliable
<
2
;
reliable
++
)
{
for
(
reliable
=
0
;
reliable
<
2
;
reliable
++
)
{
/* Stream API. */
/* Stream API. */
...
@@ -873,33 +1108,42 @@ main (int argc, char *argv[])
...
@@ -873,33 +1108,42 @@ main (int argc, char *argv[])
if
(
!
reliable
&&
stream_api_is_reliable_only
(
stream_api
))
if
(
!
reliable
&&
stream_api_is_reliable_only
(
stream_api
))
continue
;
continue
;
/* Non-reliable socket receives require large buffers. We don’t
/* Non-reliable socket receives require large buffers. We don’t claim to
* claim to support using them with small (<< 65535B) buffers, so
* support using them with small (< 65536B) buffers, so don’t test
* don’t test
them. */
*
them. */
if
(
!
reliable
&&
if
(
!
reliable
&&
receive_buffer_size_strategy
!=
BUFFER_SIZE_CONSTANT_LARGE
)
receive_buffer_size_strategy
!=
BUFFER_SIZE_CONSTANT_LARGE
)
continue
;
continue
;
/* Non-reliable socket transmits will always block with huge
/* Non-reliable socket transmits will always block with huge buffers. */
* buffers. */
if
(
!
reliable
&&
if
(
!
reliable
&&
transmit_buffer_size_strategy
==
BUFFER_SIZE_CONSTANT_LARGE
)
transmit_buffer_size_strategy
==
BUFFER_SIZE_CONSTANT_LARGE
)
continue
;
continue
;
/* Stream APIs which don’t support vectored I/O must not be passed
* I/O vectors. */
if
(
!
stream_api_supports_vectored_io
(
stream_api
)
&&
(
transmit_buffer_count_strategy
!=
BUFFER_COUNT_CONSTANT_ONE
||
transmit_message_count_strategy
!=
MESSAGE_COUNT_CONSTANT_ONE
||
receive_buffer_count_strategy
!=
BUFFER_COUNT_CONSTANT_ONE
||
receive_message_count_strategy
!=
MESSAGE_COUNT_CONSTANT_ONE
))
continue
;
g_debug
(
"Running test (%u, %u, %"
G_GSIZE_FORMAT
", %u, "
g_debug
(
"Running test (%u, %u, %"
G_GSIZE_FORMAT
", %u, "
"
%u, %u, %u, %u)…"
,
"%u, %u, %u, %u,
%u, %u, %u, %u)…"
,
reliable
,
stream_api
,
n_bytes
,
transmit_buffer_size_strategy
,
reliable
,
stream_api
,
n_bytes
,
transmit_buffer_size_strategy
,
receive_buffer_size_strategy
,
buffer_data_strategy
,
transmit_buffer_count_strategy
,
transmit_message_count_strategy
,
receive_buffer_size_strategy
,
receive_buffer_count_strategy
,
receive_message_count_strategy
,
buffer_data_strategy
,
transmit_seed
,
receive_seed
);
transmit_seed
,
receive_seed
);
test
(
reliable
,
stream_api
,
n_bytes
,
transmit_buffer_size_strategy
,
test
(
reliable
,
stream_api
,
n_bytes
,
transmit_buffer_size_strategy
,
receive_buffer_size_strategy
,
buffer_data_strategy
,
transmit_buffer_count_strategy
,
transmit_message_count_strategy
,
receive_buffer_size_strategy
,
receive_buffer_count_strategy
,
receive_message_count_strategy
,
buffer_data_strategy
,
transmit_seed
,
receive_seed
,
transmit_seed
,
receive_seed
,
deadlock_timeout
);
deadlock_timeout
);
}
}
}
}
}
}
}
done:
done:
#ifdef G_OS_WIN32
#ifdef G_OS_WIN32
...
...
Write
Preview
Markdown
is supported
0%
Try again
or
attach a new file
Attach a file
Cancel
You are about to add
0
people
to the discussion. Proceed with caution.
Finish editing this message first!
Cancel
Please
register
or
sign in
to comment