The increasing deployment of distributed sensor networks for environmental monitoring introduces challenges in data collection. Traditional Cloud-based architectures often struggle with high latency, bandwidth constraints, and scalability issues, especially when handling spatially dense and high-frequency sensor data. To address these challenges, we propose a Fog-based interpolation and Cloud aggregation framework that distributes computational tasks across Edge, Fog, and Cloud layers to enhance the efficiency of smart sensing applications. Our approach exploits localized spatial interpolation methods (e.g., Inverse Distance Weighting and Radial Basis Functions) directly at Fog nodes, allowing for fast computation and reduced data transmission to the Cloud, which remains only in charge of refining and merging the interpolated datasets. The proposed hierarchical data processing strategy minimizes network usage and enhances scalability due to local processing at the Fog layer, making it ideal for large-scale smart computing systems. The paper focuses on the analysis of the trade-offs between computational overhead, accuracy, and data transmission efficiency through an experimental validation conducted using real-world vehicles' paths. Results demonstrate that Fog-assisted interpolation can reduce latency, achieving up to 81% improvement in some cases, while maintaining accuracy comparable to a global approach in the Cloud.

In a multiple cloud environment, the placement of execution environments is crucial and may be subject to data constraints. Data could be anchored to some environments due to regulatory compliance, data sovereignty issues, or performance optimization. Consequently, applications and microservices must be designed to operate efficiently with these constraints. This en-forces specific placement strategies to obtain good performances and scalability. This paper proposes a technique to enforce a constrained data-centric deployment placement in a federated multi-cloud environment. The algorithm analyzes a graph model of microservices interaction, considering communication with data storage and adopting “anchors” for implementing a data-centric placement strategy. The results show how a better placement based on data position in multiple clouds improves performance in terms of overall system response time. This also allows microservices to offload near data sources for multi-cloud environments, improving overall system performance without violating data movement constraints.

Abstract The microservices architectural style aims at improving software maintenance and scalability by decomposing applications into independently deployable components. A common criticism about this style is the risk of increasing response times due to communication, especially with very granular entities. Locality‐aware placement of microservices onto the underlying hardware can contribute to keeping response times low. However, the complex graphs of invocations originating from users' calls largely depend on the specific workload (e.g., the length of an invocation chain could depend on the input parameters). Therefore, many existing approaches are not suitable for modern infrastructures where application components can be dynamically redeployed to take into account user expectations. This paper contributes to overcoming the limitations of static or off‐line techniques by presenting a big data pipeline to dynamically collect tracing data from running applications that are used to identify a given number of microservices groups whose deployment allows keeping low the response times of the most critical operations under a defined workload. The results, obtained in different working conditions and with different infrastructure configurations, are presented and discussed to draw the main considerations about the general problem of defining boundary, granularity, and optimal placement of microservices on the underlying execution environment. In particular, they show that knowing how a specific workload impacts the constituent microservices of an application, helps achieve better performance, by effectively lowering response time (e.g., up to a reduction), through the exploitation of locality‐driven clustering strategies for deploying groups of services.

The microservices architectural style has gained widespread acceptance. However, designing applications according to this style is still challenging. Common difficulties concern finding clear boundaries that guide decomposition while ensuring performance and scalability. With the aim of providing software architects and engineers with a systematic methodology, we introduce a novel actor-driven decomposition strategy to complement the domain-driven design and overcome some of its limitations by reaching a finer modularization yet enforcing performance and scalability improvements. The methodology uses a multi-level scalability assessment framework that supports decision-making over iterative steps. At each iteration, architecture alternatives are quantitatively evaluated at multiple granularity levels. The assessment helps architects to understand the extent to which architecture alternatives increase or decrease performance and scalability. We applied the methodology to drive further decomposition of the core microservices of a real data-intensive smart mobility application and an existing open-source benchmark in the e-commerce domain. The results of an in-depth evaluation show that the approach can effectively support engineers in (i) decomposing monoliths or coarse-grained microservices into more scalable microservices and (ii) comparing among alternative architectures to guide decision-making for their deployment in modern infrastructures that orchestrate lightweight virtualized execution units.

Continuous data streams, generated by modern sensed cities, open many opportunities and perspectives in terms of developing new innovative services. To exploit this potential, flexible and scalable platforms are needed to ease the design, development, deployment, and operations of new city services. In recent years, several problem-specific platforms have been proposed in different application domains; however, to boost the evolution of smart cities, we claim the need for city-oriented platforms that can be easily customized to address different day-to-day life challenging problems. In this paper, we present the main architectural challenges and solutions proposed for the design of a novel open-source platform (named PROMENADE) characterized by: i ) a data-driven graph-based modeling support to ensure high generality for addressing disparate problems related to the networked nature of many city infrastructures and systems, ii ) the dynamic nature of the graph entities updated in real-time from different sources ( e.g., IoT/Edge networks, data providers, etc.), and iii ) high efficiency, scalability and flexibility to easily support new city services. The platform is designed around a general-purpose core that provides a set of built-in standard features such as data ingestion , storage, processing, and visualization exposed as a collection of containerized microservices . A specialization of the platform has been developed for road networks monitoring. It has been deployed in OpenShift/Kubernetes and tested using realistic datasets collected from the city of Lyon, France. The analysis addresses an important problem of big data processing pipelines: the synchronization between data ingestion and processing in order to produce an accurate result in useful time. To this end, we study different approaches for synchronization and show how the end-to-end latency is kept under control by leveraging the scalability of the platform.

Summary Microservices architecture and continuous software engineering are becoming popular approaches for developing and operating software products. The enabling feature of this success is the independence of the execution environments hosting microservices: by insulating failures and versioning in specific microservices, a complex application benefits of high availability at runtime and agility at development time. However, execution independence does not mean functional independence. Microservices need to interact among them to fulfill a common goal of an application. The unavailability of a microservice may seriously impact other dependent microservices, limiting continuity. To address this new kind of problem in microservices architecture, we argue the necessity of a synchronization mechanism able to support microservices coordination according to their running states: dependent microservices should wait for unready ones to avoid useless and faulty interactions. In this article, we propose a new framework, Synchronizer, able to support synchronization among microservices by exploiting distributed registries for collecting health/state information about deployed containers and hosted microservices. It has been implemented for the OpenShift platform and validated in different use cases: for example, for coordinating applications bootstrap and for programming scripts of continuous deployment orchestrators, such as Jenkins. In both cases, Synchronizer worked as expected and showed the positive effects of synchronization, giving us a valuable feedback about the possibility of further extending its application and of integrating the feature in existing microservices frameworks (eg, services mesh).

The widespread diffusion of the SARS-CoV2 virus in the last months has forced many organizations in different socio-economic fields to study new technologies to counteract its presence. One of these technologies is contact tracing based on the collection of device interactions by using specific apps and device capabilities. By tracing and storing device interactions, when a person is revealed as infected after a specific test, other people who entered in contact with the infected one are notified for an early screening aimed at stopping the infection spreading.Several solutions have been developed at regional, national or continental level, according to different architectures (centralized, decentralized and hybrid) depending on the degree of desired privacy. However, none of them exploits interaction tracing to build graphs for early detection of critical identities.In this paper, we propose an architecture, a framework and an algorithm to identify, in quasi-real-time, critical spots in time-varying graphs inferred from device interactions captured by scanning Bluetooth advertisements. We show, by examples, how the approach could provide useful information for early detecting critical people in order to prioritize mass screening for improving the effectiveness and breaking infection chains. Finally, a prototype implementation is presented.

In recent years, new classes of highly dynamic, complex systems are gaining momentum. These classes include, but are not limited to IoT, smart cities, cyber-physical systems and sensor networks. These systems are characterized by the need to express behaviors driven by external and/or internal changes, i.e. they are reactive and context-aware. A desirable design feature of these systems is the ability of adapting their behavior to environment changes. In this paper, we propose an approach to support adaptive, reactive systems based on semantic runtime representations of their context, enabling the selection of equivalent behaviors, i.e. behaviors that have the same effect on the environment. The context representation and the related knowledge are managed by an engine designed according to a reference architecture and programmable through a declarative definition of sensors and actuators. The knowledge base of sensors and actuators (hosted by an RDF triplestore) is bound to the real world by grounding semantic elements to physical devices via REST APIs. The proposed architecture along with the defined ontology tries to address the main problems of dynamically re-configurable systems by exploiting a declarative, queryable approach to enable runtime reconfiguration with the help of (a) semantics to support discovery in heterogeneous environment, (b) composition logic to define alternative behaviors for variation points, (c) bi-causal connection life-cycle to avoid dangling links with the external environment. The proposal is validated in a case study aimed at designing an edge node for smart buildings dedicated to cultural heritage preservation.

Nowadays a large amount of data is originated by complex systems, such as social networks, transportation systems, computer and service networks. These systems can be effectively modeled through graphs and studied by exploiting graph metrics, such as Betweenness Centrality (BC), a popular metric to analyze node centrality. In spite of its great potential, this metric requires long computation time, especially for large graphs. In this paper, we present a novel very fast algorithm to compute exact BC of undirected, scale-free graphs. The algorithm is based on clustering and exploits structural properties of graphs to find classes of equivalent nodes. By selecting one representative node for each class, we are able to calculate BC by significantly reducing the number of single-source shortest path explorations adopted by the Brandes' algorithm. The experimental evaluation of both sequential and map-reduce parallel versions reveals that our solution largely outperforms Brandes and recent heuristics, especially for large graphs while preserving good scalability.

The ongoing digitization of cities, enabled by the diffusion of interconnected sensors and devices, makes it possible to continuously collect and analyze huge streams of data at extremely large spatio-temporal scales and fine resolutions. These data can be used to monitor, detect and anticipate different kinds of infrastructure vulnerabilities and anomalies, as well as to implement more personalized services that could improve citizens' life. In this new context, full of opportunities, it is difficult to foresee and develop, in advance, the set of applications and services that can be potentially useful for administrators and citizens to solve the manifold compelling needs a city may have to face. Novel ICT paradigms and technologies can help designing agile, general-purpose smart city platforms aimed at supporting the collection and treatment of large-scale, multi-source (streams of) data and the development of novel applications that could fulfill diverse functional requirements under strict non-functional constraints. This paper presents the reference architecture, a prototype implementation and a city-scale case-study evaluation of PROMENADE, a platform that exploits IoT/Fog/Cloud paradigms, microservices and DevOps infrastructures to guarantee continuous development of robust and reliable applications for real-time monitoring and analysis of traffic data generated by IoT devices in large smart cities. The prototype has been evaluated in a case study concerning the quasi real-time detection of road networks vulnerabilities via centrality measures from on-line traffic conditions, emulated from off-line real datasets available for the city of Lyon, France.

IoT, smart cities, cyber-physical systems and sensor networks are context-aware, highly dynamic and reactive systems.Their implementation should take into account the heterogeneity of their components and make easy the management of events unplanned at design time.According to these requirements, in this paper we propose an ontology-based approach to provide runtime models of the physical entities characterizing context-aware reactive systems.We extend SSN, a W3C standard ontology, to support complex reactive behaviors through the modeling of Logical Sensors and Actuators (LSA ontology); we also present a software architecture in which a knowledge base, structured coherently with this semantic model, is bound to real world entities by grounding (via web services) semantic elements to physical sensors and actuators.To validate the approach we discuss a case study related to smart buildings for cultural heritage preservation.

Abstract We are assisting to a paradigmatic shift in developing Web applications since their components are often distributed and deployed as services among different organizations. Their logic is based on a set of actions that can be linked together by exploiting higher level languages more suitable to address the scale of the Web. On this multi‐organization scale, applications can be influenced by different context events generated by the environment where they run. Handling these events requires run‐time adaptations of the application's behaviour to react, properly and quickly, to changes. The paper addresses these needs by proposing a programming paradigm based on “autonomic service compositions,” ie, compositions that are able to self‐change their structure, according to a specific life cycle, to allow for the continuation of execution, even if unexpected events arise. The approach exploits autonomic computing and reasoning for taking decision on information collected during processes execution. Autonomic actions on composition structures are performed using Event Condition Action rules and a set of meta‐operations. The approach is detailed, analysed, and discussed with reference to some examples derived from a real‐world application.

Computation of node betweenness centrality (BC) of weighted and directed graphs is a time-consuming task that could limit the application of such a metric for monitoring large, dynamic networks. As widely demonstrated in previous work, approximated approaches represent a solution to reduce computation time when ranking nodes according to their BC values is sufficient with respect to knowing their exact BC values. According to this observation, we have proposed a fast algorithm for computing approximated BC values for large weighted and directed graphs. It is based on the identification of pivot nodes that equally contribute to BC values of the other nodes of the network discovered via a cluster-based approach.In this paper, we focus on the performance and scalability analysis of the proposed algorithm in order to characterize its behavior with different sets of computing resources and to identify room for further improvements. To this end, we exploit a real dataset related to a transportation network. The results show that the proposed algorithm exhibits significantly lower execution times if compared with the Brandes's solution for computing exact BC values, especially when the number of available computing resources is limited. However, the speedup is not negligible even when the number of resources grows, where improvements are possible, as shown by our analysis.

The ability to detect critical spots in transportation networks is fundamental to improve traffic operations and road-network resilience in smart cities. Real-time monitoring of these networks, especially in very large metropolitan areas, is a compelling challenge due to the complexity of computing robustness metrics. This paper presents a framework for identifying vulnerabilities in very-large road networks. The framework adopts graph-based modeling of road networks and exploits big-data techniques and technologies for processing such large and complex graphs. First, we use the framework to prove the existence of a significant correlation between global efficiency and betweenness centrality. Then, we focus on an efficient algorithm, integrated in the framework, to rank the nodes according to this metric for finding potential vulnerabilities of a road network. To keep computation time under a "quasi" real-time threshold, a fast, requirement-driven, approximated strategy for computing betweenness centrality is adopted. The evaluation shows that the algorithm, integrated in the framework, exhibits a very good approximation for the most critical nodes, thus being well-suited for on-line operational monitoring.

Betweenness centrality is a metric widely used in several domains (social, biological, transportation, computer) to identify critical nodes of networks. Its exact computation is very demanding, with an O(nm) time complexity for unweighted graphs (where n is the number of nodes and m is the number of edges). Such complexity becomes an obstacle to the adoption of betweenness centrality for continuous monitoring of critical nodes in very large networks. Several solutions have been proposed to reduce computation time, mainly via parallelism, approximation or incremental recalculation. In this paper, we propose an algorithm for computing approximated values of betweenness that allows for tuning its performance on the basis of a tolerable error. The algorithm aims at reducing the number of single-source shortest-paths explorations via a pivot-based technique that exploits topological properties of graphs and clustering. It is evaluated by identifying the vulnerabilities (critical nodes) of a real-world, very-large road network. The evaluation shows that the approximation error does not significantly affect the most critical nodes, thus making the algorithm well-suited for on-line operational monitoring of road networks.

eGovernment in the new context of smart cities aims at improving the participation model of citizens that are no longer mere consumers of services designed and offered by public bodies. The availability of (open) data from the PA and third party organizations, which can be made public and widely accessible, introduces a significant paradigm shift from citizen-centric to citizen-driven eGovernment. In this direction, the mashup model (for client-side composition), with the ability to use widespread and relatively simple Web technologies, seems to be a viable approach for simplifying service creation. To ensure an adequate penetration of this new way of service offering, social-aware service discovery techniques assume a crucial role. In the paper, we propose a recommender that offers, in addition to the conventional search techniques, some support for context- aware implicit search of services, based on social information. The ability to leverage the data characterizing the activity of users in the network easies service selection: social relationships and the potential behavioral similarities between people, or in general among users linked by similar interests, enable the inference of further behavior details when they are not directly retrievable from static or even dynamic user profiles.

Unstructured peer-to-peer (P2P) architectures offer several benefits to implement semantic discovery and composition in future-generation service registries. However, their success strongly depends on the adoption of efficient techniques for disseminating semantic queries over the network. Gossip strategies significantly reduce the amount of messages with respect to flooding, but they need a predefined tuning of the effectual fanout to achieve good performance. In this paper, we compare typical gossip strategies with our proposal, which is able to dynamically exploit network knowledge to fulfil a selective choice of propagation paths in order to ensure high recall and further reduce the number of messages exchanged. We perform the comparison in a simulated environment to observe resolution time, recall and message overhead on large-size and evolving networks while searching for service compositions. We have adopted Bernoulli, Random Geometric and Scale-Free graphs to model different network topologies. The experimental results show that our approach is able to adapt to network changes and preserve high levels of recall. In particular, it reduces message overhead, with respect to both optimized flooding and the analysed gossip-based strategies, or improves the recall, whereas resolution time remains almost unchanged.

In this paper, we propose an efficient technique for improving the performance of automatic and cooperative compositions in P2P unstructured networks during service discovery. Since the adoption of flooding to exchange queries and partial solutions among the peers of unstructured networks generates a huge amount of messages, the technique exploits a probabilistic forwarding algorithm that uses different sources of knowledge, such as network density and service grouping, to reduce the amount of messages exchanged. The technique, analyzed in several network configurations by using a simulator to observe resolution time, recall and message overhead, has shown good performances especially in dense and large-scale service networks.

Event-driven programming is progressively replacing the call-stack model to improve flexibility, efficiency and scalability in SOA. Enterprise applications often deal with large messages attached to asynchronous events. This could reduce the benefits provided by event-driven programming since the need for having every information propagated as event is counterbalanced by wasting resources when large messages are entirely propagated to destinations that do not use all of them. In this paper, we propose the adoption of the D-WSLink framework for improving data transfers by using a composite and extensible declarative mechanism to inject the desired message transfer strategies into the underlying middleware. At the current stage, we focus mainly on (conditional) lazy transfer mechanisms even though the framework is able to support also smarter strategies. In particular, we compare, through an experimental analysis, our system with Apache Camel in delivering events with large attachments. The results show that the proposed approach is effective not only for programming but also at performance level.

Improving performance of Web services interactions is an important factor to burst the adoption of SOAin mission-critical applications, especially when they deal with large business objects whose transfer time is not negligible. Designing messages dynamic granularity (offloading) is a key challenge for achieving good performances. This requires the server being able to predict the pieces of data actually used by clients in order to send only such data. However, exact prediction is not easy, and consequently lazy interactions are needed to transfer additional data whenever the prediction fails. To preserve semantics, lazy accesses to the results of a Web service interaction need to work on a dedicated copy of the business object stored as application state. Thus, dynamic offloading can experience an overhead due to a prediction failure, which is the sum of round-trip and storage access delays, which could compromise the benefits of the technique. This paper improves our previous work enabling dynamic offloading for both IN and OUT parameters, and analyses how attributes copies impact on the technique, by comparing the overheads introduced by different storage technologies in a real implementation of a Web services framework that extends CXF. More specifically, we quantitatively characterize the execution contexts that make dynamic offloading effective, and the expected accuracy of the predictive strategy to have a gain in term of response time compared to plain services invocations. Finally, the paper introduces the Attribute Loading Delegation technique that enables optimized data-transfers for those applications where data-intensive multiple-interactions take place.

Pervasive access to distributed data sources by means of mobile devices is becoming a frequent realistic operational context in many application domains. In these scenarios data access may be thwarted by the scarce knowledge that users have of the application and of the underlying data schemas and complicated by limited query interfaces, due to the small size of the devices.

Transactional Memory is a novel, promising approach for simplifying parallel programming and increasing its acceptance and diffusion. Until now, almost all the research work on TM has been focused on shared-memory architectures, while very limited effort has been dedicated to TM on distributed-memory architectures. In this paper, we propose an extension of the transactional engine DSTM2, originally designed for hardware shared-memory systems, so as to run transactional applications on the nodes of a computer cluster. The framework obtained provides a software distributed shared memory with transactional consistency whereby threads running on the nodes of a cluster can access a shared memory with atomicity and isolation. So the physical private memory of each node contributes to form a global address space accessible through programming statements having transactional semantics. The extension proposed is also useful for experimentally evaluating different techniques to be employed in a distributed implementation of TM.

Composition represents today one of the most challenging approach to design complex software systems, especially in distributed environments. While two different views (in time and in space) are considered by researchers to compose applications, we aim at applying these two views in an integrated approach. In particular, we believe that large-scale composition in an open world is simplified by using composition in time, whereas, in the closed environment of a cluster, composition in space is more effective. In the paper, we propose the integration of a workflow engine with ProActive objects to support together the two kinds of composition at different scale-level. The paper shows the first results of this integration and highlights the plan for achieving a stronger integration with the use of GCM components.

Efficient exploitation of grids for running scientific workflows could benefit of resource brokering systems to automatically and transparently allocate tasks to available resources in the Internet granting the fulfillment of functional and QoS constraints. Existing works typically do not deal with business models to map tasks to resources. Since the service oriented approach is fostering a new vision of grid computing, economic aspects will become key factors to burst the adoption of computing as a utility. This paper presents a time and cost-constrained matching strategy that, according to the data parallelism pattern, is able to deploy a scientific workflow task on a pool of resources selected with the aim of minimizing its execution time. The strategy was implemented in a grid broker and its validity was experimentally analyzed with a real grid of clusters and workstations.

Asynchronous invocation and continuation are common patterns in some middleware infrastructures for object-based distributed computing. Their benefits are particularly significant in distributed environments characterized by high communication latencies and coarse-grained operations. Therefore, Web services could strongly benefit from the adoption of these patterns to (1) overlap communication with computation, (2) reduce the high number of interactions typically needed to handle stateless services by migrating the state of a service as parameters of service operations, (3) intercept at run-time data dependencies among consecutive services in a composition not visible from service descriptions. Unfortunately, current semantics of Web services do not directly support the patterns, but some specifications (i.e. WS-addressing) can simplify their implementation. In the paper we present the patterns, their benefits, and a module that implements a flexible schema useful to perform asynchronous invocations in several contexts. This way, modelling composed services can benefit from abstractions whilst more sophisticated low-level interactions among services are automatically handled at run-time.

In large-scale distributed systems, asynchronous communication and future objects are becoming wide spread mechanisms to tolerate high latencies and to improve global performances. Automatic continuation, that is the propagation of a future object outside the activity that has generated it, can be used to further increase concurrency at system level through the anticipation of tasks. An important aspect of automatic continuation, which can cause different performance in different application and deployment scenarios, is the mechanism for updating result values of future objects, when they are ready. In this paper, we analyze the behaviour of the implementation of different updating strategies, by comparing them with the one currently implemented in ProActive. The experimental results show that the lazy home-based strategy behaves better than other strategies in some application scenarios that are very common in distributed applications.

Web Services are becoming more and more fundamental building blocks of Web-based distributed applications and a core technology for grid systems. Due to their flexibility, Web Services easily combine, in a common and coherent framework, ubiquitous computing with heterogeneous applications composed of different kinds of resources and, typically distributed in many organizations. We expect that this technology will follow the same evolution paths that have characterized other technologies so far, with some specificity due to the openness and size of the application context. In this connection, optimizations tied to invocations and workflows are assuming a primary role in Web Services research. The synchronous request/reply nature of the most diffused underling protocol (HTTP) introduces several restrictions in many application scenarios. On the other hand, asynchronous interactions are allowed by using message oriented middleware platforms, like JMS, which are typically harder to handle than object- and process-oriented middleware. In this paper, we propose a first implementation of a module that allows for dynamic Web Services invocations, which, on the basis of metadata added to WSDL, is able to select the most appropriate invocation technique for calling a Web Services operation.

Grid computing is becoming a prominent field of interest for distributed systems. The capability to support resource sharing between different organizations and the high level of performance are noteworthy features. However, to define, deploy and execute grid applications require significant design effort and complex resource coordination, which can be alleviated by using workflow management systems. This technology is more and more adopted in distributed systems and grids since it ensures easiness and flexibility at design-time and performance and dynamicity at run-time. This paper gives a contribution to performance improvements of workflow by presenting a technique to exploit fine-grained concurrency at run-time. The technique is implemented in a workflow enactment service that dynamically optimizes process execution limiting the design effort of application developers

The paper describes TCPTE, a framework that supports the development of thin-client applications for mobile devices. By using this framework, Java AWT applications can be executed on a server and their graphical interfaces can be displayed on a remote client. TCPTE combines in a single framework the advantages of thin-client computing with the richness of client-server graphical interfaces and the simplicity of development that characterizes desktop applications.

In heterogeneous distributed systems, such as grids, a resource broker is responsible of automatically selecting resources, and mapping application tasks to them. A crucial aspect of resource broker design, especially in a next commercial exploitation of grid systems, in which economy theories for resource management will be applied, is the support to task mapping based on the fulfillment of quality of service (QoS) constraints. The paper presents an economy-driven mapping heuristic, called time minimization, for mapping and scheduling the tasks assigned to the slaves of a master-slave application in a hierarchical and heterogeneous distributed system. The validity and accuracy of such heuristic are tested by implementing it in a resource broker of a hierarchical grid middleware used for running a real world application.

Workflow enactment systems are becoming an effective solution to ease programming, deployment and execution of distributed applications in several domains such as telecommunication, manufacturing, e-business, e-government and grid computing. In some of these fields, efficiency and traffic optimization represent key aspects for a wide diffusion of workflow engines and modeling tools. This paper focuses on a technique that enables fine-grained concurrency in compute and data-intensive workflows and reduces the traffic on the network by limiting the number of interactions to the ones strictly needed to bring the data where they are really necessary for continuing the flow of computations. We implemented this technique by using the concepts of wait by necessity and automatic continuation and we integrated it in a flexible, Java workflow engine that through the new mechanisms is able to navigate a workflow anticipating the enactment of sequential activities

Optimal control and management of power systems require extensive analyses of phenomena that can compromise their operation in order to evaluate their impact on the security and reliability levels of the electrical networks. For complex networks, this process, known as power systems contingencies analysis, requires large computational efforts, whereas computation times should be less than a few minutes for the information to be useful. Even though many architectures based on conventional parallel and distributed systems have been widely proposed in the literature, they are characterized by low extensibility, reusability, and scalability, and so, they require a sensible hardware upgrade when more computational resources are necessary. This event is not infrequent in power systems where the constant growth of the electrical network complexity and the need for larger security and reliability levels of the plant infrastructures lead to the need of more detailed contingency analysis in shorter times. To address this problem, this paper proposes a pervasive grid approach to define a user-friendly software infrastructure for data acquisition from electrical networks and for data processing in order to simulate possible contingencies in a real electrical network. The grid infrastructure adopts a brokering service, based on an economy-driven model, to satisfy the quality of service constraints specified by the user (i.e., a time deadline to simulate the contingencies). This paper also discusses the deployment of the infrastructure on a network of heterogeneous clusters and PCs to compute the contingency analysis of a realistic electrical network. The experimental results obtained demonstrate the effectiveness of the proposed solution and the potential role of grid computing in supporting intensive computations in power systems

The proliferation of different kinds of mobile devices, ranging from personal wireless devices, such as PDAs and smart phones, to small notebooks, is enabling ubiquitous personal computing. However, even if a personal device is able to access to different kinds of information, often it does not represent the best solution to retrieve a stream of data from the Internet or to visualize it with an acceptable quality. This problem is promoting several research efforts oriented to the definition of techniques and network components able to support the migration of working sessions from a device to a more apt one. Research results related to the mobility of hosts are not sufficient to solve the problem of user mobility. The paper presents a protocol built a top HTTP for enabling session hand-off in Web applications, which, by exploiting a proxy-based architecture, is able to work without interventions on existing applications and Web infrastructure.

Summary form only given. We dealt with the definition and implementation of a distributed Web-based architecture for the online power system security analysis. The architecture employs field data measurements to dynamically estimate the actual state of an electrical grid and solves, for each possible contingency, the power system state equations to classify critical contingencies that could lead to system vulnerabilities. To identify the critical contingencies a computational engine able to execute the power system state equations is implemented according to a variant of the master/slave pattern. This pattern is defined to easily leverage the hierarchical network topology of resources connected to the Internet. The pattern is implemented with both RMI and ProAactive, while the resulting framework is deployed on a network of heterogeneous clusters and used to compute the contingency analysis of a realistic electrical grid. The experimental results demonstrate that online security analysis can be executed in few minutes even for large network complexity.

An increasingly popular mechanism to carry out dispatching of HTTP requests inside distributed Web servers is based on the analysis of request content. This is typically realized in the user space since an implementation in the kernel space may result in difficulties due to the connection oriented nature of TCP. Nevertheless, some kernel-based techniques have been proposed in recent years, such as TCP-splicing, redirect flows and TCP hand-off. Although the last one is the most efficient technique, currently few real implementations exist. The paper presents the implementation of a variant of TCP hand-off, which enables an efficient content-aware scheduling in the kernel space of Linux O.S., and discusses a hybrid scheduling algorithm based on the prediction of the content of disk caches. The paper compares the results obtained by the new algorithm with those obtained by a pure content-aware one and proposes solutions for improving transparency and scalability of TCP hand-off.

Distributed platforms for live and on-demand media streaming delivery such as content distribution networks and media on-demand systems, are being diffused mainly due to the widespread availability of IP-based, bandwidth-capable digital networks. Provision of multimedia group services is usually supported by transmitting media streams to subscribers organized in a multicast group. Although multicast streaming saves bandwidth and improves scalability, it is prone to be hacked. This paper proposes an efficient technique centered on the Blowfish symmetric encryption algorithm for securing media streams based on the real-time transport protocol (RTP). The developed technique along with an ad-hoc key distribution mechanism is seamlessly embedded into our Java-based cooperative playback system - ViCRC/sup C/, which allows multicast transmission on-demand of archived multimedia sessions to a cooperative group of clients.