Information Technology Reference
In-Depth Information
Similar to the interconnect performance, we can note that there are multiple orders
of magnitude difference between the individual mechanisms, which impact on the
instance handling speed accordingly.
2.3
Programmability
Programmability is a major issue for full usage of cloud systems. Keeping the wide
customer base in mind, the programming language should adhere to well-established
models, such as Java, C#, PHP etc. Notably, the language of the application itself is
secondary, if full-fledged virtual images are provided (IaaS), but is of major concern
in PaaS environments, where the extensions typically adhere to a specific language.
Stand-alone, non-adapted code versions work fine in IaaS cases where each
instance can be treated completely isolated. Once dependencies, i.e. shared data is
introduced, the application logic needs to be altered accordingly. If the developer
wants to control specific features of the cloud behaviour (such as scaling behaviour),
the according knowledge needs to be encoded right into the logic. It is worth noting in
this context that not all cloud providers automate the elastic behaviour, but expose an
according programming interface to the developer to trigger instantiation himself.
The main task therefore consists in rewriting the logic to externalise content and
part of the logic. One subsequently introduces delays for data-exchange, which is
proportional to the factors discussed above. A straight-forward approach may consist
in externalising the database system and sharing it between instances, but this will
create a bottleneck, which may counter all benefits from migrating to the cloud in the
first instance. Introducing dedicated synchronisation points similarly leads to
communication delays that delimit the execution performance.
Modern programming models allow for easy integration of web interactions and
cloud features, but the relationship to the actual performance and behaviour is not
clear. In other words, the available languages are not able to compensate for the
deficiencies introduced by the algorithm itself. For example it makes a major
difference whether the developer intends to share a large database that is updated
multiple times, or whether the application effectively just exchanges data at session
begin or end time. The language allows for either way without giving indicators of the
performance impact, let alone controlling this impact. Most languages completely rely
on the framework, respectively middleware to execute the transactions. This means
that the user cannot estimate the timing impact correctly.
Lower level domains, such as HPC, therefore do not rely on managed
communication frameworks, but essentially leave full control with the developer.
Extensions provided through MPI or OpenMP only expose standardised mechanisms
for common procedures, rather than taking responsibility away from the programmer.
Thus, the program has to be instance aware to deal with the dynamic instantiation and
relocation - typically it is therefore only exploited under very controlled conditions.
To optimally exploit the cloud characteristics, partial and conditional sharing of
both code and data would have to be supported and ideally widely automated. No
current programming model allows for such support though and the manual approach
currently undertaken by e.g. HPC is highly complex, leaving only very few people
ready to deal with it in the first instance.
