Networked Systems

The spanning tree entropy of a complex network provides a useful insight about its robustness. The most robust network is the network that has the highest entropy. In this paper, we represent construction of a complex network called Flower Network by using two combinatorial approaches: (1) Bipartition and (2) Reduction. We based both methods on geometrical transformation. We also develop topological properties of the network, obtain analytical expression for its number of spanning trees. In the end, we calculate and compare its spanning tree entropy with those for other networks having the same average degree of nodes for estimating a robust network.

The problem of the universal mobile telecommunication system (UMTS) network assignment is divided into two assignment sub-problems: the assignment of a set of Nodes Bs to a set of radio network controllers (RNCs), and the assignment of those RNC concurrently to a set of Mobile Switching Centers (MSCs) and a set of Serving GPRS Support Nodes (SGSNs). The objective is to find an assignment that minimizes the cost of such implementation.This paper proposes, first, an improvement of the existing mathematical modelling. Second, it presents a solution method to the problem based on genetic algorithms with a dynamic approach. To compare our proposed model to the existing one, some numerical examples are given. The obtained results show the efficiency of our model and our approach.

One of the very serious problems facing a MANET (Mobile Ad hoc Network) is very limited life of its mobile nodes. Most MANET routing protocols use hop count as the cost metric, so the nodes along shortest paths may be used more often and exhaust their batteries faster, these protocols do not consider the energy problem because there is no exchange of information on the state of mobile nodes between the MAC protocol (Medium Access Control) and the routing protocols in order to support the power saving mechanisms. In this paper we propose the improvements of one of the most important routing protocols that is AODV (Ad hoc On demand Distance Vector). These improvements take into account a metric based on energy consumption during route discovery, thereby increasing the network lifetime, packet delivery ratio and decreasing load of control packets. Most researches in this domain are based on an ideal radio channel, in which a successful transmission is guaranteed if the distance between nodes is less than a certain threshold. However, wireless communication links normally suffer from the characteristics of realistic physical layer. So in order to give credibility to our work we use a realistic physical layer by modeling transmission errors by the Gilbert-Elliot model.

In recent years, mobile ad hoc network (MANET) is becoming more and more useful in many domains. While MANETs still suffer from several problems. Among these problems, the energy conservation. Where the energy presents one of the greatest restriction, and has a massive effect on others metrics like packet delivery ratio, overhead, end-to-end delay and the lifetime of the network. As most of mobile ad hoc stations based on a limited battery in their mission. For these reasons, we propose in this paper a fuzzy logic system (FLS) to enhance the performance of one of the reactive routing protocols Ad hoc On-demand Distance Vector (AODV) by avoiding nodes with low amount of energy and select the more stable path. Our fuzzy system uses three input parameters that have a large impact on the stability of the links: energy drain rate, mobility of the node and the distance between two communicating nodes. Simulation results show that our protocol gives good result by reducing significantly the energy dissipation, also certain parameters affected by the energy issue.

Current reconfiguration techniques depend on starting the system in a consistent configuration, in which all participating entities are in a predefined state. Starting from that state, the system must preserve consistency as long as a predefined churn rate of processors joins and leaves is not violated, and unbounded storage is available. Many systems cannot control this churn rate and lack access to unbounded storage. System designers that neglect the outcome of violating the above assumptions may doom the system to exhibit illegal behaviors. We present the first automatically recovering reconfiguration scheme that recovers from transient faults, such as temporal violations of the above assumptions. Our self-stabilizing solutions regain safety automatically by assuming temporal access to reliable failure detectors (FDs). Once safety is established, the FD reliability is no longer needed. Still, liveness is conditioned by the FD’s unreliable signals. Our self-stabilizing reconfiguration techniques can serve as the basis for the implementation of several dynamic services over message passing systems. Examples include self-stabilizing reconfigurable virtual synchrony, extendable to a self-stabilizing reconfigurable state machine replication.

The design of distributed gathering and convergence algorithms for tiny robots has recently received much attention. In particular, it has been shown that the convergence problem, that is, the problem of moving robots close to each other (i.e., inside an area of some maximum size, where the position of the area is not fixed beforehand), can even be solved for very weak, oblivious robots: robots which cannot maintain state from one round to the next. The oblivious robot model is hence attractive from a self-stabilization perspective, where the state is subject to adversarial manipulation. However, to the best of our knowledge, all existing robot convergence protocols rely on the assumption that robots, despite being “weak”, can measure distances.We in this paper initiate the study of convergence protocols for even simpler robots, called monoculus robots: robots which cannot measure distances. In particular, we introduce two natural models which relax the assumptions on the robots’ cognitive capabilities: (1) a Locality Detection ($$\mathscr {LD}$$) model in which a robot can only detect whether another robot is closer than a given constant distance or not, (2) an Orthogonal Line Agreement ($$\mathscr {OLA}$$) model in which robots only agree on a pair of orthogonal lines (say North-South and West-East, but without knowing which is which).The problem turns out to be non-trivial, as simple strategies like median and angle bisection can easily increase the distances among robots (e.g., the area of the enclosing convex hull) over time. Our main contribution is deterministic self-stabilizing convergence algorithms for these two models. We also show that in some sense, the assumptions made in our models are minimal: by relaxing the assumptions on the monoculus robots further, we run into impossibility results.

Attribute-based access control (ABAC) represents a generic model of access control that provides a high level of flexibility and promotes information and security sharing. Since ABAC considers a large set of attributes for access decisions, using it might get very complicated for large systems. Hence, it is interesting to offer techniques to reduce the number of rules in ABAC policies without affecting the final decision. In this paper, we present an approach based on K-nearest neighbors algorithms for clustering ABAC policies. To the best of our knowledge, it is the first approach that aims to reduce the number of policy rules based on similarity computations. Our evaluation results demonstrate the efficiency of the suggested approach. For instance, the reduction rate can reach up to 10% for an ABAC policy with more than 9000 rules.

Recommender systems are designed to find items in which each user has most likely the highest interest. Items can be of any type such as commercial products, e-learning resources, movies, songs, and jokes. Successful web and mobile applications can collect easily thousands of users, thousands of items, and millions of item ratings in only few months. A solution to store and to process these continuously growing data is to build distributed recommender systems. The challenging task is to find the appropriate distribution strategy allowing an efficient retrieval of needed information. Considering the similarity between the task of predicting a rating, and the task of predicting a membership grade in graded multi-label classification (GMLC), we propose an adapted distribution strategy to efficiently build a decentralized recommender system based on GMLC.

K-Nearest Neighbors algorithm (KNN) is the core of a considerable amount of online services and applications, like recommendation engines, content-classifiers, information retrieval systems, etc. The users of these services change their preferences over time, aggravating the computational challenges of KNN. In this work, we present UpKNN: an efficient thread-based out-of-core approach to take the updates of users preferences into account while it computes the KNN efficiently.

Implementing atomic read/write shared objects in a message-passing system is an important problem in distributed computing. Considering that communication is the most expensive resource, efficiency of read and write operations is assessed primarily in terms of the needed communication and the associated latency. Attiya, Bar-Noy, and Dolev established that two communication round-trip phases involving in total four message exchanges are sufficient to implement atomic operations when a majority of processors are correct. Subsequently Dutta et al. showed that one round involving two communication exchanges is sufficient as long as the system adheres to certain constraints with respect to crashes on the number of readers and writers in the system. It was also observed that three exchanges are sufficient in some settings.This extended abstract presents work that explores algorithms where operations are able to complete in three message exchanges without imposing constraints on the number of participants, i.e., the aim is One and half Round Atomic Memory, hence the name Oh-RAM! Recently Hadjistasi et al. showed that three-exchange implementations are impossible in the MWMR (multi-writer/multi-reader) setting. This paper shows that this is achievable in the SWMR (single-writer/multi-reader) setting, and also achievable for read operations in the MWMR setting by “sacrificing” the performance of write operations. In particular, a SWMR implementation is presented, where reads complete in three and writes complete in two exchanges. Next, a MWMR implementation is given, where reads involve three and writes involve four exchanges. In light of the impossibility result these algorithms are optimal in terms of the number of communication exchanges. Both algorithms are then refined to allow some reads to complete in just two exchanges. These algorithms are evaluated and compared using the NS3 simulator with different topologies and operation loads.

Robustness is a correctness notion for concurrent programs running under relaxed consistency models. The task is to check that the relaxed behavior coincides (up to traces) with sequential consistency (SC). Although computationally simple on paper (robustness has been shown to be PSPACE-complete for TSO, PGAS, and Power), building a practical robustness checker remains a challenge. The problem is that the various relaxations lead to a dramatic number of computations, only few of which violate robustness.In the present paper, we set out to reduce the search space for robustness checkers. We focus on store-atomic consistency models and establish two completeness results. The first result, called locality, states that a non-robust program always contains a violating computation where only one thread delays commands. The second result, called singularity, is even stronger but restricted to programs without lightweight fences. It states that there is a violating computation where a single store is delayed.As an application of the results, we derive a linear-size source-to-source translation of robustness to SC-reachability. It applies to general programs, regardless of the data domain and potentially with an unbounded number of threads and with unbounded buffers. We have implemented the translation and verified, for the first time, PGAS algorithms in a fully automated fashion. For TSO, our analysis outperforms existing tools.

A policy is a sequence of rules, where each rule consists of a predicate and a decision, and where each decision is either “accept” or “reject”. A policy P is said to accept (or reject, respectively) a request iff the decision of the first rule in P, that matches the request is “accept” (or “reject”, respectively). Examples of computing policies are firewalls, routing policies and software-defined networks in the Internet, and access control policies. In this paper, we present a generalization of policies called policy expressions. A policy expression is specified using one or more policies and the three policy operators: “not”, “and”, and “or”. We show that policy expressions can be utilized to support bottom-up methods for designing policies. We also show that each policy expression can be represented by a set of special types of policies, called slices. Finally, we present several algorithms that use the slice representation of given policy expressions to verify whether the given policy expressions satisfy logical properties such as adequacy, implication, and equivalence.

Authorization in collaborative systems is defined by a global policy that represents the combination of the collaborators’ access policies. However, the enforcement of such a global policy may create conflicting authorization decisions. In this paper, we categorize two types of conflicts that may occur in such policies. Furthermore, to resolve these conflicts and to reach a unique decision for an access request, we present an approach that uses XACML policy combining algorithms and considers the category of the detected conflicts. The approach is implemented using aspect-oriented finite state machines.

The paper proposes a surprisingly simple characterization of a large class of models of distributed computing, via an agreement function: for each set of processes, the function determines the best level of set consensus these processes can reach. We show that the task computability of a large class of fair adversaries that includes, in particular superset-closed and symmetric one, is precisely captured by agreement functions.

Shared data structures are a basic building block in distributed computing, but can be expensive to implement. One way to circumvent the high implementation cost of linearizability is to relax the sequential specification of the data type. This gives up some guarantees, for instance on the ordering of data elements, as a tradeoff against performance. We want to explore the effects of this tradeoff on the computational power of the shared data structures.In this paper, we characterize the effects of three different types of relaxation, chosen from the literature, on the computational power of FIFO queues. By parametrically relaxing each of the three operations on a queue (Enqueue, Dequeue, Peek), we obtain an infinite 3-dimensional space for each type of relaxation. We find the consensus number, a standard measure of the computational power of shared data types, of each point in these spaces, completely describing the effect of these three types of relaxation on the computational power of queues.

Consensus is the most basic agreement problem encountered in fault-tolerant distributed computing: each process proposes a value and non-faulty processes must agree on the same value, which has to be one of the proposed values. While this problem is impossible to solve in asynchronous systems prone to process crash failures, it can be solved in synchronous (round-based) systems where all but one process might crash in any execution. It is well-known that $$(t+1)$$ rounds are necessary and sufficient in the worst case execution scenario for the processes to decide and stop executing, where $$t < n$$ is a system parameter denoting the maximum number of allowed process crashes and n denotes the number of processes in the system.Early decision and stopping considers the case where $$f<t$$ processes actually crash, f not being known by processes. It has been shown that the number of rounds that have to be executed in the worst case is then $$\mathsf{min}(f+2,t+1)$$. Following Castañeda, Gonczarowski and Moses (DISC 2014), the paper shows that this value is an upper bound attained only in worst execution scenarios. To this end, it investigates a sequence of three early deciding/stopping predicates $$P_1=P_\mathsf{count}$$, $$P_2=P_\mathsf{dif}$$ and $$P_3=P_\mathsf{pref0}$$, of increasing power, which differ in the information obtained by the processes from the actual failure, communication and data pattern. It is shown that each predicate $$P_i$$ is better than the previous one $$P_{i-1}$$, $$i\in \{2,3\}$$, in the sense that there are executions where $$P_i$$ allows processes to reach a decision earlier than $$P_{i-1}$$, while $$P_{i-1}$$ never allows a process to decide earlier than $$P_i$$. Moreover, $$P_3=P_\mathsf{pref0}$$ is an unbeatable predicate in the sense that it cannot be strictly improved: if there is an early deciding/stopping predicate $$P'$$ that improves the decision time of a process with respect to $$P_\mathsf{pref0}$$ in a given execution, then there is at least one execution in which a process decides with $$P'$$ strictly later than with $$P_\mathsf{pref0}$$.

Shared objects are the means by which processes gather and exchange information about the state of a distributed system. Objects that disclose more information about the system are therefore more desirable. In this paper, we propose the schedule reconstruction (SR) problem as a new metric for the disclosure power of shared memory objects. In schedule reconstruction, processes take steps which are interleaved to form a schedule; each process needs to be able to reconstruct the schedule up to its last step. We show that objects can be ranked in a hierarchy according to their ability to solve SR. In this hierarchy, stronger objects can implement weaker objects via a SR-based universal construction. We identify a connection between SR and consensus and prove that SR is at least as hard as consensus. Perhaps surprisingly, we show that objects that are powerful in solving consensus—such as compare-and-swap—are not always powerful in their ability to solve SR.

This paper studies a fundamental dynamic clustering problem. The input is an online sequence of pairwise communication requests between n nodes (e.g., tasks or virtual machines). Our goal is to minimize the communication cost by partitioning the communicating nodes into $$\ell $$ clusters (e.g., physical servers) of size k (e.g., number of virtual machine slots). We assume that if the communicating nodes are located in the same cluster, the communication request costs 0; if the nodes are located in different clusters, the request is served remotely using inter-cluster communication, at cost 1. Additionally, we can migrate: a node from one cluster to another at cost $$\alpha \ge 1$$.We initiate the study of a stochastic problem variant where the communication pattern follows a fixed distribution, set by an adversary. Thus, the online algorithm needs to find a good tradeoff between benefitting from quickly moving to a seemingly good configuration (of low inter-cluster communication costs), and the risk of prematurely ending up in a configuration which later turns out to be bad, entailing high migration costs.Our main technical contribution is a deterministic online algorithm which is $$O(\log {n})$$-competitive with high probability (w.h.p.), for a specific but fundamental class of problems: namely on ring graphs.

A fundamental challenge in unstructured peer-to-peer systems is how to identify rare resources. Actual solutions only base on local information of peers or from their direct neighbors, which is not enough to know if resources are rare or not. We propose a Resource Availability Measurement for mobile P2P systems which considers knowledge from all peers of the system. Preliminary simulation results show that our estimation of availability is close to the real one.

Lazy sequentialization has proven to be one of the most effective techniques for concurrent program verification. The Lazy-CSeq sequentialization tool performs a “lazy” code-to-code translation from a concurrent program into an equivalent non-deterministic sequential program, i.e., it preserves the valuations of the program variables along its executions. The obtained program is then analyzed using sequential bounded model checking tools. However, the sizes of the individual states still pose problems for further scaling. We therefore use abstract interpretation to minimize the representation of the concurrent program’s (shared global and thread-local) state variables. More specifically, we run the Frama-C abstract interpretation tool over the programs constructed by Lazy-CSeq to compute overapproximating intervals for all (original) state variables and then exploit CBMC’s bitvector support to reduce the number of bits required to represent these in the sequentialized program. We have implemented this approach in the last release of Lazy-CSeq and demonstrate the effectiveness of this approach; in particular, we show that it leads to large performance gains for very hard verification problems.

In this paper we address the problem of solving parity games over the configuration graphs of bounded phase multi-pushdown systems. A non-elementary decision procedure was proposed for this problem by A. Seth. In this paper, we provide a simple and inductive construction to solve this problem. We also prove a non-elementary lower-bound, answering a question posed by A. Seth.

In this paper, we consider the reachability problem of multi-threaded programs where threads have priorities and are scheduled by a priority based round-robin scheduler. For that, we introduce a new model, called Dynamic Pushdown Networks with Priorities (P-DPNs) that extends the well known DPN model with priorities. We represent potentially infinite sets of configurations of P-DPNs using finite state automata and show that the backward reachability sets of P-DPNs are regular and can be effectively computed.

Software-defined networking (SDN), network functions virtualization (NFV) and network virtualization (NV) build a mini-cosmos inside data centers, cloud providers, and enterprises.The network virtualization allows new on-demand management capabilities, in this work we demonstrate such a service, namely, on-demand efficient monitoring or anonymity. The proposed service is based on network virtualization of expanders or sparsifiers over the physical network. The defined virtual (or overlay) communication graphs coupled with a multi-hop extension of Valiant randomization based routing lets us monitor the entire traffic in the network, with a very few monitoring nodes.In particular, we show that using overlay network with expansion properties and Valiant randomized load balancing it is enough to place O(m) monitor nodes when the length of the overlay path (number of intermediate nodes chosen by Valiant’s routing procedure) is O(n/m).We propose two randomized routing methods to implement policies for sending messages, and we show that they facilitate efficient monitoring of the entire traffic, such that the traffic is distributed uniformly in the network, and each monitor has an equiprobable view of the network flow. In terms of complex networks, our result can be interpreted as a way to enforce the same betweenness centrality to all nodes in the network.Additionally, we show that our results are useful in employing anonymity services. Thus, we propose monitoring or anonymity services, which can be deployed and shut down on-demand. Our work is the first, as far as we know, to bring such on-demand infrastructure structuring using the cloud NV capability to existing monitoring or anonymity networks. We propose methods that theoretically improve services provided by existing anonymity networks, and optimize the degree of anonymity, in addition to providing robustness and reliability to system usage and security.At last, we believe, that our constructions of overlay expanders and sparsifiers weighted network, that use several random walk trees, are of independent interest.

The proliferation of mobile devices and location-based services (LBS) is strongly challenging user privacy. Users disclose a large volume of sensitive information about themselves to LBS. Indeed, such services collect user locations to operate and can thus use them to perform various inference attacks. Several privacy mechanisms and metrics have been proposed in the literature to preserve location privacy and to quantify the level of privacy obtained when these mechanisms are applied on raw locations. Although the use of these metrics is relevant under specific threat models, they cannot anticipate the level of location privacy on the sole basis of the altered location data shared with LBS. Therefore, we propose a location privacy estimator that approximates the level of location privacy based on spatio-temporal uncertainties resulting from location alterations produced when a location privacy preserving mechanism is applied on user raw locations. This estimator also takes into account spatial-temporal user privacy parameters. We also describe the computation of the spatio-temporal uncertainties through the sampling, the Gaussian perturbation as well as the spatial cloaking. Finally, we compare the results of our estimator with those of the success of two localization attacks. The findings show that our estimator provides reasonable or conservative estimates of the location privacy level.

In the past years, researchers developed approaches to detect spam in Online Social Networks (OSNs) such as URL blacklisting, spam traps and even crowdsourcing for manual classification. Although previous work has shown the effectiveness of using statistical learning to detect spam, existing work employs supervised schemes that require labeled training data. In addition to the heavy training cost, it is difficult to obtain a comprehensive source of ground truth for measurement. In contrast to existing work, in this paper we present AdaGraph that is a novel graph-based approach for spam detection. AdaGraph is unsupervised, hence it diminishes the need of labeled training data and training cost. Particularly, AdaGraph effectively detects spam in large-scale OSNs by analyzing user behaviors using graph clustering technique. Moreover, AdaGraph continuously updates detected communities to comply with users dynamic interactions and activities. Extensive experiments using Twitter datasets show that AdaGraph detects spam with accuracy 92.3%. Furthermore, the false positive rate of AdaGraph is less than 0.3% that is less than half of the rate achieved by the state-of-the-art approaches.

Civitas is the first fully remote e-voting protocol which ensures verifiability and coercion resistance at the same time. In 2011, Shirazi et al. found a security flaw on the credential management process during Civitas’ registration phase and proposed solutions to avoid this drawback.In this paper, we describe some attacks found during the Civitas’ registration phase. We show that Shirazi’s solutions cannot be used in practical situations and/or doesn’t ensure coercion-resistance. Then, we present a fully remote e-voting protocol that addresses these drawbacks.Our protocol aims to separate voter’s registration data from voter’s vote into two different bulletin boards. Merging this data will only be done by tallying authorities to identify and tally valid votes. Moreover, our protocol uses a new ballot’s encryption function that ensures coercion resistance in a different manner. Compared to Civitas, we use a secure registration phase and we reduce the computational complexity of tallying phase from quadratic to linear time.

Nowadays, software systems have become an essential element in our daily life. To ensure the quality and operation of software, testing activities have become primordial in the software development life cycle (SDLC). Indeed, software bugs can potentially cause dramatic consequences if the product is released to the end user without testing. The software testing role is to verify that the actual result and the expected result are consistent and ensure that the system is delivered without bugs. Many techniques, approaches and tools have been proposed to help check that the system is defect free. In this paper, we highlight two software testing techniques considered among the most used techniques to perform software tests, and then we perform a comparative study of these techniques, the approaches that supports studied techniques, and the tools used for each technique. We have selected the first technique based on the 2014 survey [62] that heighted the motivations for using the Model-based-testing, and by analyzing the survey results we have found that some MBT limits are benefits in Risk based testing, the second technique in our study.

Integrating digital into the DNA of their business model is an essential part of business success for companies across industries today. The digital transformation has become a critical management issue and requires new ways of managerial thinking. In this context, we address the specificity of digital projects compared to IT projects in general, to innovate during the implementation of digital projects following their trends generated by digital transformation, while respecting the triangle “Quality, Price, Duration”. To do this, we adopt a methodology based on describing the management tasks and roles of digital project manager to identify obstacles to digital transformation in digital project management, then analyze these obstacles to countermeasure them and propose a new knowledge based system “KBS” based on the feedback of digital experiences.

The use of internet is becoming larger, in more and more diverse situations, going from messaging, e-mailing, video and data transfers, to cloud computing, and internet of things (IoT). Users are willing to connect to any wireless access technology, anywhere and anytime to satisfy the ‘ABC’ (Always Best Connected). This leads to vertical handovers (VH). VH differs from horizontal handover (i.e., the transfer of connections between two base stations or access points with the same access technology). The transfer must be without session breaks.In this paper, we propose a new hybrid decision method for VH decision process, named FGRA combining Fuzzy sets and Gray Relational Analysis (GRA) to perform more efficient VH decisions. Moreover, our combination allows the VHs to be seamless, without session ruptures. This new method is compared with the normal MADM methods GRA and TOPSIS, known for their efficiency in this context, in terms of number of handovers, and the QoS offered in every decision point. Our new hybrid method gives better results than the classical ones through the simulation scenarios’ results we perform.

Establishing the scalability of a concurrent algorithm a priori, before implementing and evaluating it on a concrete multi-core platform, seems difficult, if not impossible. In the context of search data structures however, according to all practical work of the past decade, algorithms that scale share a common characteristic: They all resemble standard sequential implementations for their respective data structure type and strive to minimize the number of synchronization operations.In this paper, we present sequential proximity, a theoretical framework to determine whether a concurrent search algorithm is close to its sequential counterpart. With sequential proximity we take the first step towards a theory of scalability for concurrent search algorithms.

Spark is a new promising platform for scalable data-parallel computation. It provides several high-level application programming interfaces (APIs) to perform parallel data aggregation. Since execution of parallel aggregation in Spark is inherently non-deterministic, a natural requirement for Spark programs is to give the same result for any execution on the same data set. We present PureSpark, an executable formal Haskell specification for Spark aggregate combinators. Our specification allows us to deduce the precise condition for deterministic outcomes from Spark aggregation. We report case studies analyzing deterministic outcomes and correctness of Spark programs.

The predominant notion for specifying problems to study distributed computability are tasks. Notable examples of tasks are consensus, set agreement, renaming and commit-adopt. The theory of task solvability is well-developed using topology techniques and distributed simulations. However, concurrent computing problems are usually specified by objects. Tasks and objects differ in at least two ways. While a task is a one-shot problem, an object, such as a queue or a stack, typically can be invoked multiple times by each process. Also, a task, defined in terms of sets, specifies its responses when invoked by each set of processes concurrently, while an object, defined in terms of sequences, specifies the outputs the object may produce when it is accessed sequentially.In a previous paper we showed how tasks can be used to specify one-shot objects (where each process can invoke only one operation, only once). In this paper we show how the notion of tasks can be extended to model any object. A potential benefit of this result is the use of topology, and other distributed computability techniques to study long-lived objects.

Recently, there has been an increased research interest in telecommunication network pricing, which leads to many proposals for new pricing schemes motivated by different objectives namely: to maximize service provider’s revenue, to guarantee fairness among users and to satisfy QoS requirements for differentiated network services.In present paper, we consider a Bertrand model with N rational Service Providers (SPs) that offer homogeneous telecommunication services to customers. We assume that all SPs offer the same services and seek to persuade more customers in the same market, we model this conflict as a non-cooperative game. On the one hand, each SP decide his policies of price and Quality of Service (QoS) in order to maximize his profit. On the other hand, we assume that the customers are boundedly rational and make their subscription decisions probabilistically, according to Luce choice probabilities. Furthermore, they decide to which SP to subscribe, each one may migrate to another SP or alternatively switch to “no subscription state” depending on the observed price/QoS. In this work, we have shown that the SPs have an interest in confusing customers i.e. more than the customers are irrational, the SPs earn more.

Energy consumption is of main concern in the field of Wireless Video Sensor Networks (WVSNs) where energy resources are limited, consisting only in the battery of the sensor nodes that determines their lifetime. In this paper, we propose an empirical parametric model to predict the energy consumption of a High Efficiency Video Coding (HEVC) based video encoder in its intra-only mode, used in the context of the next generation WVSNs. Such model is of great interest to adapt the waste of energy of the encoding phase to the remaining energy budget of the node, while meeting the required video quality. The proposed model predicts the energy consumption, considering the adopted Quantization Parameter (QP) and the Frame Rate parameter (FR). A Raspberry Pi 2 card based video sensor node is used for modelling and validation, considering different configurations and spatial resolutions. The obtained results demonstrate that the proposed model describes well the occurred energy dissipation during the video encoding phase, with an average prediction error of 4.5%.