Information Technology Reference
In-Depth Information
not all tested transmission types support arbitrary data sizes. Due to the XML
encoding - especially of arrays - the test of a byte array was limited by the
available heap space for the Java virtual machine. The heap space was set to 2
GB and the Java Garbage Collector was allowed to run concurrently. Only with
this setup we were able to test the transmission of byte arrays containing up to
800
,
000 single byte values.
Aspect serviceaAspect = new Aspect(
new QName("http://fb12.de/AosStringTestService",
"AosStringTestService"), "echoStringA", "/data",
Aspect.AOP_RESPONSE_MODE , "FlexSwAPlugIn")
Listing 1.3.
Java bean constructor of an aspect
We have compared the workflow execution times for the three different echo
service scenarios (each measurement was repeated 100 times) to show their rel-
ative speedups. The less effective the data transfer mechanism is, the higher the
(relative) runtime improvement is, if request/response aspects are used. In case
of the byte array, a large improvement of up to 50% could be achieved, i.e.,
the transmission of a byte array in the size of 800 kbytes took about 95824 sec
using plain SOAP communication and about 50190 sec using request/response
aspects in combination with Flex-SwA. The runtime improvement of up to 50 %
can be explained as follows: As indicated in Figure 1, each SOAP transmission
first requires a serialization, then the actual transmission over a network and
finally a deserialization - repeated in each step 1 - 4. Thus, the overall runtime
time can be determined as
T
SOAP
=4
t
(
n
)+
ε
,where
t
(
n
) is the network
transmission time, including the serialization and deserialization time, and
n
is
the amount of transmitted data (
ε
represents negligible processing times). In
case of the Flex-SwA request/response aspect, step 2 and step 3 now transport
the woven reference instead of the actual payload. Since the size of a reference
is independent of the referenced amount of data, the runtime can be expressed
as
T
R/R
=2
∗
t
+
t
D
(
n
)+
ε
,where
t
is the corresponding time for
transferring a reference and
t
D
(
n
) is the time needed to transfer the payload
via Flex-SwA. For large
n
,weobtain
t
∗
t
(
n
)+2
∗
t
(
n
),
t
D
(
n
)
≤
t
(
n
) and thus we get
T
n→∞
R/R
t
(
n
)+
t
D
(
n
). The comparison of
T
SOAP
and
T
n→∞
R/R
indicates that
the theoretical runtime improvement is (slightly) below 50 %. Our measurements
show that the proposed framework can come close to this theoretical limit. On
the other hand, the overhead introduced by the request/response aspect is no-
ticeable for the small data sizes when using strings or SOAP with Attachments
(cf., Figure 2), but for larger data sizes (
>
40 KBytes) the achieved runtime
improvement outweighs this overhead.
It is worth mentioning that not only the execution time of such a workflow
can be accelerated by a significant factor, but also the development time is
shortened considerably. This reduction in development time results from the fact
that simple data types can be used for the development of the services and that
=2
∗
