Search

Summary: Fault‐tolerance and self‐organization are critical properties in modern distributed systems. Self‐stabilization is a class of fault‐tolerant distributed algorithms which has the ability to recover from any kind and any finite number of transient faults and topology changes. In this article, we propose a self‐stabilizing distributed algorithm for the 1‐MIS problem under the unfair central daemon assuming the distance‐3 model. Here, in the distance‐3 model, each process can refer to the values of local variables of processes within three hops. Intuitively speaking, the 1‐MIS problem is a variant of the maximal independent set (MIS) problem with improved local optimizations. The time complexity (convergence time) of our algorithm is O(n)$$ O(n) $$ steps and the space complexity is O(logn)$$ O\left(\log n\right) $$ bits, where n$$ n $$ is the number of processes. Finally, we extend the notion of 1‐MIS to p$$ p $$‐MIS for each nonnegative integer p$$ p $$, and compare the set sizes of p$$ p $$‐MIS (p=0,1,2,...$$ p=0,1,2,\dots $$) and the maximum independent set. [ABSTRACT FROM AUTHOR]

Traditional hydro-pneumatic spring suspensions are limited to a single vertical degree of freedom, which cannot accommodate the significant technological changes introduced by the new in-wheel motor drive mode. Integrating the motor into the vehicle's hub creates a direct motor drive mode, replacing the traditional engine–transmission–drive shaft configuration. Together with the dual in-wheel motor wheelset structure, this setup can achieve both drive and differential steering functions. In this study, we designed a six-arm suspension wheel-leg device based on hydro-pneumatic springs, and its structural composition and functional characteristics are presented herein. The external single-chamber hydro-pneumatic springs used in the six-arm structure suspension were analyzed and mathematically modeled, and the nonlinear characteristic curves of the springs were derived. To overcome the instability caused by inconsistent extension lengths of the hydro-pneumatic springs during horizontal steering, the spring correction force, horizontal rotational torque, consistency, and stiffness of the six-degree-of-freedom hydro-pneumatic spring wheel-leg device were analyzed. Finally, with the auxiliary action of tension springs, the rotational torque of the hydro-pneumatic springs and the tension resistance torque of the tension spring counterbalanced each other, keeping the resultant torque on the wheelset at approximately 0 N∙m. The results suggest that the proposed device has excellent self-stabilizing performance and meets the requirements for straight-line driving and differential steering applications. This device provides a new approach for the drive mode and suspension design of the dual in-wheel motor wheelset. [ABSTRACT FROM AUTHOR]

Mainstream compilers perform a multitude of analyses and optimizations on the given input program. Each analysis (such as points-to analysis) may generate a program-abstraction (such as points-to graph). Each optimization is typically composed of multiple alternating phases of inspection of such program-abstractions and transformations of the program. Upon transformation of a program, the program-abstractions generated by various analyses may become inconsistent with the modified program. Consequently, the correctness of the downstream inspection (and consequent transformation) phases cannot be ensured until the relevant program-abstractions are stabilized; that is, the program-abstractions are either invalidated or made consistent with the modified program. In general, the existing compiler frameworks do not perform automated stabilization of the program-abstractions and instead leave it to the compiler pass writers to deal with the complex task of identifying the relevant program-abstractions to be stabilized, the points where the stabilization is to be performed, and the exact procedure of stabilization. In this article, we address these challenges by providing the design and implementation of a novel compiler-design framework called Homeostasis. Homeostasis automatically captures all the program changes performed by each transformation phase, and later, triggers the required stabilization using the captured information, if needed. We also provide a formal description of Homeostasis and a correctness proof thereof. To assess the feasibility of using Homeostasis in compilers of parallel programs, we have implemented our proposed idea in IMOP, a compiler framework for OpenMP C programs. Furthermore, to illustrate the benefits of using Homeostasis, we have implemented a set of standard data-flow passes, and a set of involved optimizations that are used to remove redundant barriers in OpenMP C programs. Implementations of none of these optimizations in IMOP required any additional lines of code for stabilization of the program-abstractions. We present an evaluation in the context of these optimizations and analyses, which demonstrates that Homeostasis is efficient and easy to use. [ABSTRACT FROM AUTHOR]

DC magnetic suspension operated by transmitted power is introduced to AC magnetic suspension system using magnetic resonant coupling for dynamic stabilization. The target AC magnetic suspension system has a self-stabilization property. Although restoring force is produced without active control in this system, damping is necessary for dynamic stabilization. To generate damping force, a DC magnetic suspension mechanism, which is operated by the power transmitted to the floator through magnetic resonant coupling, is installed in parallel with the AC magnetic suspension mechanism. The newly developed system has a pair of AC electromagnets and another pair of DC electromagnets. The former pair generates positive stiffness according to the self-stabilization property. The latter pair is expected to produce positive damping by shortening the coil of the electromagnet on the stator. However, it is experimentally shown that negative damping is produced because the latter pair also has the self-stabilization property. Therefore, a bias voltage is applied to the DC electromagnet on the stator to make the stiffness negative. As a result, stable suspension is achieved without active control in the developed system. However, the overall stiffness decreases and the stability range is small because the latter pair has negative stiffness. To solve such a problem, a phase-lead compensation is applied to the latter pair instead of the bias voltage. This method can produce positive damping and positive stiffness at the same time so that the suspension characteristics are improved.

Summary: The domination problem is one of the fundamental graph problems, and there are many variations. In this article, we propose a new problem called the minus (L,K,Z)$$ \left(L,K,Z\right) $$‐domination problem where L,K$$ L,K $$, and Z$$ Z $$ are integers such that L≤−1$$ L\le -1 $$, K≥1$$ K\ge 1 $$, and Z≥1$$ Z\ge 1 $$. The problem is to assign a value from L,L+1,...,0,...,K−1,K$$ L,L+1,\dots, 0,\dots, K-1,K $$ for each vertex in a graph such that the local summation of values is greater than or equal to Z$$ Z $$. We also propose a framework named the bounded lattice domination for a class of domination problems, including the minus (L,K,Z)$$ \left(L,K,Z\right) $$‐domination problem. Then, we present a self‐stabilizing distributed algorithm under the distance‐2 model for the bounded lattice domination. Here, self‐stabilization is a class of fault‐tolerant distributed algorithms that tolerate transient faults. The time complexity for convergence is O(n)$$ O(n) $$, where n$$ n $$ is the number of processes in a network if the cardinality of the domain of process values is finite and constant. Otherwise, the time complexity for convergence is O(n2)$$ O\left({n}^2\right) $$. [ABSTRACT FROM AUTHOR]

Traditional hydro-pneumatic spring suspensions are limited to a single vertical degree of freedom, which cannot accommodate the significant technological changes introduced by the new in-wheel motor drive mode. Integrating the motor into the vehicle’s hub creates a direct motor drive mode, replacing the traditional engine–transmission–drive shaft configuration. Together with the dual in-wheel motor wheelset structure, this setup can achieve both drive and differential steering functions. In this study, we designed a six-arm suspension wheel-leg device based on hydro-pneumatic springs, and its structural composition and functional characteristics are presented herein. The external single-chamber hydro-pneumatic springs used in the six-arm structure suspension were analyzed and mathematically modeled, and the nonlinear characteristic curves of the springs were derived. To overcome the instability caused by inconsistent extension lengths of the hydro-pneumatic springs during horizontal steering, the spring correction force, horizontal rotational torque, consistency, and stiffness of the six-degree-of-freedom hydro-pneumatic spring wheel-leg device were analyzed. Finally, with the auxiliary action of tension springs, the rotational torque of the hydro-pneumatic springs and the tension resistance torque of the tension spring counterbalanced each other, keeping the resultant torque on the wheelset at approximately 0 N∙m. The results suggest that the proposed device has excellent self-stabilizing performance and meets the requirements for straight-line driving and differential steering applications. This device provides a new approach for the drive mode and suspension design of the dual in-wheel motor wheelset.

A self-stabilizing distributed algorithm is guaranteed eventually to reach and stay at a legitimate configuration regardless of the initial configuration of a distributed system. In this paper, we propose the generalized dominating set problem, which is a generalization of the dominating set and |$k$| -redundant dominating set problems. In the generalized dominating set we propose in this paper, each node |$P_{i}$| is given its set of domination wish sets, and a generalized dominating set is a set of nodes such that each node is contained in the set or has a wish set in which all its members are in the set. We propose a self-stabilizing distributed algorithm for finding a minimal generalized dominating set in an arbitrary network under the unfair distributed daemon. The proposed algorithm converges in |$O(n^{3}m)$| steps and |$O(n)$| rounds, where |$n$| (resp. |$m$|⁠) is the number of nodes (resp. edges). Furthermore, it has the safe convergence property with safe convergence time in |$O(1)$| rounds. The space complexity of the proposed algorithm is |$O(\Delta \log n)$| bits per node, where |$\Delta $| is the maximum degree of nodes. [ABSTRACT FROM AUTHOR]

We study the classic load balancing problem on dynamic general graphs, where the graph changes arbitrarily between the computational rounds, remaining connected with no permanent cut. A lower bound of Ω(n2) for the running time bound in the dynamic setting, where n is the number of nodes in the graph, is known even for randomized algorithms. We solve the problem by deterministic distributed algorithms, based on a short local deal-agreement communication of proposal/deal in the neighborhood of each node. Our synchronous load balancing algorithms achieve a discrepancy of 휖 within the time of O (n D log (n K / 휖)) for the continuous setting and the discrepancy of at most 2D within the time of O (n D log (n K / D)) and a 1-balanced state within the additional time of O(nD2) for the discrete setting, where K is the initial discrepancy, and D is a bound for the graph diameter. Also, the stability of the achieved 1-balanced state is studied. The above results are extended to the case of unbounded diameter, essentially keeping the time bounds, via special averaging of the graph diameter over time. Our algorithms can be considered anytime ones, in the sense that they can be stopped at any time during the execution, since they never make loads negative and never worsen the state as the execution progresses. In addition, we describe a version of our algorithms, where each node may transfer load to and from several neighbors at each round, as a heuristic for better performance. The algorithms are generalized to the asynchronous distributed model. We also introduce a self-stabilizing version of our asynchronous algorithms. [ABSTRACT FROM AUTHOR]

In this paper, we present sasa , an open-source SimulAtor of Self-stabilizing Algorithms. Self-stabilization defines the ability of a distributed algorithm to recover after transient failures. sasa is implemented as a faithful representation of the atomic-state model (also called the locally shared memory model with composite atomicity). This model is the most commonly used one in the self-stabilizing area to prove both the correct operation of self-stabilizing algorithms and complexity bounds on them. sasa encompasses all features necessary to debug, test and analyze self-stabilizing algorithms. All these facilities are programmable to enable users to accommodate to their particular needs. For example, asynchrony is modeled by programmable stochastic daemons playing the role of input sequence generators. Properties of algorithms can be checked using formal test oracles. The sasa distribution also provides several facilities to easily achieve (batch-mode) simulation campaigns. We show that the lightweight design of sasa allows to efficiently perform huge such campaigns. Following a modular approach, we have aimed at relying as much as possible the design of sasa on existing tools, including ocaml , dot and several tools developed in the Synchrone Group of the VERIMAG laboratory. [ABSTRACT FROM AUTHOR]

The development of PVC materials grafted with mannich base originated from myrcene (P-MAM-g, where the mannich base derived from myrcene is abbreviated as MAM) via green and effective synthetic methods is a good strategy to avoid unacceptable discoloration and deterioration of thermal and mechanical properties caused by autocatalytic dehydrochlorination (DHC) during PVC processing. In this study, MAM with double bonds, amino groups, ester groups, and phospholipid groups was introduced into the chains of PVC to improve the thermal stability of PVC. The experimental results showed that the covalent attachment of MAM to PVC enhanced both the initial and the long-term stability of PVC. The enhanced performance of P-MAM-g compared with unmodified PVC is attributed to the simultaneous introduction of double bonds and amino groups into the PVC structure. The double bonds trapped the unstable chlorine atoms originated from the degradation of the PVC chain and reacted with the labile macromolecular radicals originated from PVC, thus inhibiting the radical degradation of the PVC chain. Furthermore, the amino groups absorbed the HCl produced in the degradation of PVC, inhibiting the adverse effects of HCl. P-MAM-g displayed better intrinsic flexibility and anti-migration ability of organic functional components compared with the control PVC materials. A possible stabilizing mechanism of the P-MAM-g was also presented. [ABSTRACT FROM AUTHOR]

In this article, we study some parallel processing algorithms for multiplication and modulo operations. We demonstrate that the state transitions that are formed under these algorithms satisfy lattice-linearity, where these algorithms induce a lattice among the global states. Lattice-linearity implies that these algorithms can be implemented in asynchronous environments, where the nodes are allowed to read old information from each other. It means that these algorithms are guaranteed to converge correctly without any synchronization overhead. These algorithms also exhibit snap-stabilizing properties, i.e., starting from an arbitrary state, the sequence of state transitions made by the system strictly follows its specification. • We show that modulo and multiplication are lattice-linear operations. • We study self-stabilizing algorithms for these operations. • Due to lattice-linearity, these algorithms can tolerate asynchrony. • For each problem, the algorithms that we study manifest different lattice structures. • This difference is because they require different numbers of computing nodes. [ABSTRACT FROM AUTHOR]

Unlike qualitative properties such as correctness (safety and liveness), quantitative properties of distributed algorithms have only been certified in very few studies. This work is the first attempt to certify time complexity bounds of a fault-tolerant distributed algorithm. Our case study consists in formally proving, using the Coq proof assistant, the time complexity of the first Dijkstra's self-stabilizing token ring algorithm. In more detail, we formally prove both the self-stabilization and exact worst-case stabilization time of this algorithm assuming asynchronous settings. This latter result is obtained in two main steps. First, we certify a non-trivial upper bound on the stabilization time, i.e. , every execution in an N -size ring contains at most 3 ⋅ N ⋅ (N − 1) 2 − N − 1 steps if N ≥ 4 , at most 3 steps if N = 3 ; and in remaining cases, the stabilization time is zero. Then, for each case, we exhibit a possible execution whose complexity exactly matches those upper bounds. Notice that the tight bounds for N = 3 and N ≥ 4 were unknown until now, even among self-stabilization researchers. • This work is the first attempt to certify the time complexity of a fault-tolerant distributed algorithm. • The case study consists in the worst case stabilization time in steps of the first self-stabilizing algorithm proposed by Dijkstra. • The complexity analysis is complete: we certify the exact worst case stabilization time in steps of the algorithm. [ABSTRACT FROM AUTHOR]

In this paper, we propose the first self-stabilizing c-wave algorithm for broadcasting large size messages from multiple initiator processes such that every process receives at least one of these messages broadcast by the initiators. The proposed algorithm first splits each message into a sequence of message shares and then broadcasts the message shares in a pipelined manner in order. We then present an improved maximally concurrent self-stabilizing c-wave algorithm called dynamic clusteringc-wavealgorithm that constructs dynamic broadcast trees by allowing a process to dynamically change its parent to a neighbouring process with the most message shares to implement a maximally concurrent broadcasting of large size messages. The improved algorithm is maximally concurrent in the sense that a process is allowed to receive a message share from any neighbouring process with a larger sequence of message shares than its current parent from which it receives message shares in the broadcast trees constructed by the initiators when available. We implemented and experimentally evaluated the c-wave algorithm to compare its message propagation delay to those of the m and the k-wave algorithms. Simulation results show that the proposed algorithm significantly reduces the broadcast propagation delays compared to that of the m and the k-wave algorithms. The improvement is more evident over the m-wave algorithm. Solutions to global-snapshots, distributed broadcast and various synchronization problems can be solved efficiently using c-wave algorithms. In addition, the proposed algorithms have applications in blockchain, mobile wireless sensor networks, VANETs and military communication networks. [ABSTRACT FROM AUTHOR]

We study the problem of privately emulating shared memory in message-passing networks. The system includes clients that store and retrieve replicated information on N servers, out of which e are data-corrupting malicious. When a client accesses a data-corrupting malicious server, the data field of that server response might be different from the value it originally stored. However, all other control variables in the server reply and protocol actions are according to the server algorithm. For the coded atomic storage algorithms by Cadambe et al., we present an enhancement that ensures no information leakage and data-corrupting malicious fault-tolerance. We also consider recovery after the occurrence of transient faults that violate the assumptions according to which the system was designed to operate. After their last occurrence, transient faults leave the system in an arbitrary state (while the program code stays intact). We present a self-stabilizing algorithm, which recovers after the occurrence of transient faults. This addition to Cadambe et al. considers asynchronous settings as long as no transient faults occur. The recovery from transient faults that bring the system counters (close) to their maximal values may include the use of a global reset procedure, which requires the system run to be controlled by a fair scheduler. After the recovery period, the safety properties are provided for asynchronous system runs that are not necessarily controlled by fair schedulers. Since the recovery period is bounded and the occurrence of transient faults is extremely rare, we call this design criteria self-stabilization in the presence of seldom fairness. Our self-stabilizing algorithm uses a bounded amount of storage during asynchronous executions (that are not necessarily controlled by fair schedulers). To the best of our knowledge, we are the first to address privacy, data-corrupting malicious behavior, and self-stabilization in the context of emulating atomic shared memory in message-passing systems. [ABSTRACT FROM AUTHOR]

Given a boolean predicate Π on labeled networks (e.g., proper coloring, leader election, etc.), a self-stabilizing algorithm for Π is a distributed algorithm that can start from any initial configuration of the network (i.e., every node has an arbitrary value assigned to each of its variables), and eventually converge to a configuration satisfying Π. It is known that leader election does not have a deterministic self-stabilizing algorithm using a constant-size register at each node, i.e., for some networks, some of their nodes must have registers whose sizes grow with the size n of the networks. On the other hand, it is also known that leader election can be solved by a deterministic self-stabilizing algorithm using registers of O(log log n) bits per node in any n-node bounded-degree network. We show that this latter space complexity is optimal. Specifically, we prove that every deterministic self-stabilizing algorithm solving leader election must use (log log n)-bit per node registers in some n-node networks. In addition, we show that our lower bounds go beyond leader election, and apply to all problems that cannot be solved by anonymous algorithms. [ABSTRACT FROM AUTHOR]

The low‐temperature‐processed amorphous oxide semiconductors (AOSs) exhibit remarkable potentials in large‐area, flexible, and hybrid‐integrated electronics, while the performance and stability of AOS devices highly depend on the proper manipulation of abundant native defects in AOS, especially for AOS Schottky barrier diode (SBD) with the naturally defective metal–semiconductor interface. Here, a hydrogenated‐InGaZnO SBD with a hydrogen‐rich passivation layer (PL) is reported. With the hydrogenation effectively suppressing interface defects and meanwhile donating electrons, a near‐ideal Schottky contact and more‐conductive drift region are simultaneously achieved, as proven by the perfect ideality factor of 1.08, a Schottky barrier height of 0.87 eV, a high rectification ratio ≈4.5 × 108. Moreover, such sophisticated hydrogenation is self‐stabilized by the bilayer structure of PL, contributing to the record‐high stabilities under harsh environmental and electrical stresses. [ABSTRACT FROM AUTHOR]

By introducing programmability, automated verification, and innovative debugging tools, Software-Defined Networks (SDNs) are poised to meet the increasingly stringent dependability requirements of today's communication networks. However, the design of fault-tolerant SDNs remains an open challenge. This paper considers the design of dependable SDNs through the lenses of self-stabilization—a very strong notion of fault-tolerance. In particular, we develop algorithms for an in-band and distributed control plane for SDNs, called Renaissance, which tolerate a wide range of failures. Our self-stabilizing algorithms ensure that after the occurrence of arbitrary failures, (i) every non-faulty SDN controller can reach any switch (or another controller) within a bounded communication delay (in the presence of a bounded number of failures) and (ii) every switch is managed by a controller. We evaluate Renaissance through a rigorous worst-case analysis as well as a prototype implementation (based on OVS and Floodlight, and Mininet). [ABSTRACT FROM AUTHOR]

Today, there is a tendency to reduce the dependence on local computation in favor of cloud computing. However, this inadvertently increases the reliance upon distributed fault-tolerant systems. In a condition that forced to work together, these systems often need to reach an agreement on some state or task, and possibly even in the presence of some misbehaving Byzantine nodes. Although non-trivial, Byzantine Agreement (BA) protocols now exist that are resilient to these types of faults. However, there is still a risk for inconsistencies in the application state in practice, even if a BA protocol is used. A single transient fault may put a node into an illegal state, creating a need for new self-stabilizing BA protocols to recover from illegal states. As self-stabilization often comes with a cost, primarily in the form of communication overhead, a potential lowering of latency - the cost of each message - could significantly impact how fast the protocol behaves overall. Thereby, there is a need for new network protocols such as QUIC, which, among other things, aims to reduce latency. In this paper, we survey current state-of-the-art agreement protocols. Based on previous work, some researchers try to implement pseudocode like QUIC protocol for Ethereum blockchain to have a secure network, resulting in slightly slower performance than the IP-based blockchain. We focus on consensus in the context of blockchain as it has prompted the development and usage of new open-source BA solutions that are related to proof of stake. We also discuss extensions to some of these protocols, specifically the possibility of achieving self-stabilization and the potential integration of the QUIC protocol, such as PoS and PBFT. Finally, further challenges faced in the field and how they might be overcome are discussed.

Rapid growth in the number of users, devices and applications and infrastructures generating and demanding massive amount of content traffic on the Internet has necessitated the available network infrastructures to evolve to cope up with the ever increasing content traffic. One of the approaches in reducing the content traffic and increasing the network throughput is the paradigm of multicast. Multicast is a one-to-many wave scheme for content distribution from a source to all or a large number of destinations. In this paper, we propose the first novel reliable concurrent content multicast algorithm, referred to as a CD-wave algorithm, for concurrent distribution of content from some or all peers to all other network peers. The proposed algorithm synchronises concurrent multicasts in sharing network resources while providing the desirable properties of self- and snap-stabilization. Concurrent mulicasts from different sources are synchronized so that multiple multicasts use each network channel mutually exclusively while ensuring that each multicast eventually succeeds to deliver its content to all system peers. Due to being reliable, each multicast content is guaranteed to be received by all system peers exactly once regardless of the arbitrary initial system configuration in the presence of potentially n - 1 other multicasts competing for network resources where n denotes the number of peers in the network. The snap-stabilization property of our proposed algorithm facilitates the reliability property by ensuring that content distribution proceeds as per its specification to reach all system peers without backtracking after starting in an arbitrary initial configuration. [ABSTRACT FROM AUTHOR]

Wireless sensor networks (WSNs) achieving environmental sensing are fundamental communication layer technologies in the Internet of Things. Battery-powered sensor nodes may face many problems, such as battery drain and software problems. Therefore, the utilization of self-stabilization, which is one of the fault-tolerance techniques, brings the network back to its legitimate state when the topology is changed due to node leaves. In this technique, a scheduler decides on which nodes could execute their rules regarding spatial and temporal properties. A useful graph theoretical structure is the vertex cover that can be utilized in various WSN applications such as routing, clustering, replica placement and link monitoring. A capacitated vertex cover is the generalized version of the problem which restricts the number of edges covered by a vertex by applying a capacity constraint to limit the covered edge count. In this paper, we propose two self-stabilizing capacitated vertex cover algorithms for WSNs. To the best of our knowledge, these algorithms are the first attempts in this manner. The first algorithm is stabilized under an unfair distributed scheduler (that is, the scheduler which does not grant all enabled nodes to make their moves but guarantees the global progress of the system) at most O (n 2) step, where n is the count of nodes. The second algorithm assumes 2-hop (degree 2) knowledge about the network and runs under the unfair scheduler, which subsumes the synchronous and distributed fair scheduler and stabilizes itself after O (n) moves in O (n) step, which is acceptable for most WSN setups. We theoretically analyze the algorithms to provide proof of correctness and their step complexities. Moreover, we provide simulation setups by applying IRIS sensor node parameters and compare our algorithms with their counterparts. The gathered measurements from the simulations revealed that the proposed algorithms are faster than their competitors, use less energy and offer better vertex cover solutions. [ABSTRACT FROM AUTHOR]

Randomization is a key concept in distributed computing to tackle impossibility results. This also holds for self-stabilization in anonymous networks where coin flips are often used to break symmetry. Although the use of randomization in self-stabilizing algorithms is rather common, it is unclear what the optimal coin bias is so as to minimize the expected convergence time. This paper proposes a technique to automatically synthesize this optimal coin bias. Our algorithm is based on a parameter synthesis approach from the field of probabilistic model checking. It over- and under-approximates a given parameter region and iteratively refines the regions with minimal convergence time up to the desired accuracy. We describe the technique in detail and present a simple parallelization that gives an almost linear speed-up. We show the applicability of our technique to determine the optimal bias for the well-known Herman's self-stabilizing token ring algorithm. Our synthesis obtains that for small rings, a fair coin is optimal, whereas for larger rings a biased coin is optimal where the bias grows with the ring size. We also analyze a variant of Herman's algorithm that coincides with the original algorithm but deviates for biased coins. Finally, we show how using speed reducers in Herman's protocol improve the expected convergence time. [ABSTRACT FROM AUTHOR]

Jinran Li,1 Yuxi Jia,1 Peng Zhang,2 Huailin Yang,2 Xianling Cong,1 Lin An,3 Chunsheng Xiao2,4 1Department of Dermatology, China-Japan Union Hospital, Jilin University, Changchun 130033, People’s Republic of China; 2Key Laboratory of Polymer Ecomaterials, Changchun Institute of Applied Chemistry, Chinese Academy of Sciences, Changchun 130022, People’s Republic of China; 3Department of Hand Surgery, China-Japan Union Hospital of Jilin University, Changchun 130033, People’s Republic of China; 4Jilin Biomedical Polymers Engineering Laboratory, Changchun 130022, People’s Republic of ChinaCorrespondence: Xianling Cong; Lin An Tel +86-431-89876626; +86-431-84995523Email congxl@jlu.edu.cn; anlin.changchun@163.comBackground: Celastrol (CEL), a triterpene extracted from the Chinese herb tripterygium wilfordii, has been reported to have profound anticancer activities. However, poor water solubility and high side toxicities have severely restricted the clinical applications of CEL.Purpose: We proposed a facile “in situ drug conjugation-induced self-assembly” strategy to prepare CEL-loaded nanoparticles (CEL-NPs) that exhibited enhanced antitumor activity against melanoma.Methods: First, the CEL was chemically conjugated onto a methoxyl poly(ethylene glycol)-b-poly(L-lysine) (mPEG-PLL) backbone, resulting in the conversion of the double hydrophilic mPEG-PLL polymer into an amphiphilic polymer prodrug, mPEG-PLL/CEL. The obtained mPEG-PLL/CEL could self-assemble into stable micelles in aqueous solution due to the hydrophobic association of CEL moieties in the side chains and the possible electrostatic interaction between the carboxyl group in CEL and the residue amine group in the PLL segment. Thus, the obtained mPEG-PLL/CEL nanoparticles were named CEL self-stabilized nanoparticles (CEL-NPs), which were then characterized by dynamic light scattering and transmission electron microscopy. Furthermore, the antitumor effects of the CEL-NPs were investigated by an MTT assay in vitro and in a B16F10 tumor-bearing mice model.Results: The CEL-NPs exhibited sustained drug release behavior and were effectively endocytosed by B16F10 cells. Furthermore, the in vivo antitumor evaluation demonstrated that the CEL-NPs had remarkably higher tumor growth inhibition rates and lower systemic side effects than free CEL.Conclusion: In summary, our present work not only demonstrates the generation of stable CEL-loaded nanoparticles for the efficient treatment of melanoma but also describes a general way to prepare drug self-stabilized nanomedicine for anticancer therapy.Keywords: celastrol, self-assembly, self-stabilization, nanomedicine, melanoma

We propose a general scheme to compute tree-based data structures on arbitrary networks. This scheme is self-stabilizing, silent, and despite its generality, also efficient. It is written in the locally shared memory model with composite atomicity assuming the distributed unfair daemon, the weakest scheduling assumption of the model. Its stabilization time is in at most 4 n maxCC rounds, where n maxCC is the maximum number of processes in any connected component of the network. We illustrate the versatility and efficiency of our approach by proposing several instantiations solving classical spanning tree problems such as DFS, BFS, shortest-path, or unconstrained spanning tree/forest constructions, as well as other fundamental problems like leader election or finding maximum-bottleneck-bandwidth paths. We also exhibit polynomial upper bounds on its stabilization time in steps and process moves, holding for a large class of instantiations. In several cases, the polynomial step and move complexities we obtain for those instantiations match the best known complexities of existing algorithms, despite the latter being dedicated to particular problems. Furthermore, a significant set of instantiations of our scheme requires only bounded memory space per process. This set includes, but is not limited to, DFS, BFS, and shortest-path spanning tree constructions. [ABSTRACT FROM AUTHOR]

Copyright of Zeitschrift für Psychodrama und Soziometrie is the property of Springer Nature and its content may not be copied or emailed to multiple sites or posted to a listserv without the copyright holder's express written permission. However, users may print, download, or email articles for individual use. This abstract may be abridged. No warranty is given about the accuracy of the copy. Users should refer to the original published version of the material for the full abstract. (Copyright applies to all Abstracts.)

In this paper, we propose and analyze an online, decentralized policy for dispatching vehicles in a multi-line public transit system. In the policy, vehicles arriving at a terminal station are assigned to the lines starting at the station in a round-robin fashion. Departure times are selected to minimize deviations from a certain target headway. We prove that this policy is self-organizing: given that there is a sufficient number of available vehicles, a timetable spontaneously emerges that meets the target headway of every line. Moreover, in case one of the vehicles breaks down, the remaining vehicles automatically redistribute over the network to re-establish such a timetable. We present both theoretical and numerical results on the time until a stable state is reached and on how quickly the system recovers after the breakdown of a vehicle. Experiments on three real-world transit systems show that our policy performs well, even if not all assumptions required for the theoretical analysis are met: if there are enough vehicles, the realized headways are typically close to the target headways. These promising results suggest that our self-organizing policy could be useful in situations where centralized dispatching is impractical or simply impossible due to an abundance of disruptions or the absence of information systems. • A simple decentralized policy for dispatching in a multi-line network is proposed. • We show analytically that the policy matches the performance of centralized control. • Numerical experiments using real networks confirm the good performance of the policy. [ABSTRACT FROM AUTHOR]

Self-stabilization is a general paradigm that characterizes the ability of a distributed system to recover from transient faults. Since its introduction by Dijkstra in 1974, self-stabilization has been successfully applied to efficiently solve many networking tasks. However, most of the literature focuses on bidirectional networks. Now, in today's networks such as WSNs, some communication channels may be one-way only. Considering such network topologies, a.k.a. directed graphs, makes self-stabilization more complicated, and sometimes even impossible. In this paper, we investigate the gap in terms of requirements and efficiency when considering a directed graph instead of an undirected one as network topology for a self-stabilizing algorithm. Our case study is a variant of a synchronous unison algorithm proposed by Arora et al.; the synchronous unison being a clock synchronization problem. • We address self-stabilization of dynamic problems in anonymous directed networks. • We propose a topology-related necessary condition to solve synchronous unison in directed networks. • We present a simple self-stabilizing synchronous unison algorithm for directed networks. • We study conditions under which the proposed algorithm is self-stabilizing, and at what cost. [ABSTRACT FROM AUTHOR]