Multi-scale self-simulation: A technique for reconfiguring arrays with faults

Richard Cole, Bruce Maggs, Ramesh Sitaraman

Research output: Chapter in Book/Report/Conference proceedingConference contribution

Abstract

In this paper we study the ability of array-based networks to tolerate faults. We show that an N×N two-dimensional array can sustain N1-ε worst-case faults, for any fixed ε>0, and still emulate a fully functioning N×N array with only constant slowdown. We also observe that even if every node fails with some fixed probability, p, with high probability the array can still emulate a fully functioning array with constant slowdown. Previously, no connected bounded-degree network was known to be able to tolerate constant-probability node failures without suffering more than a constant-factor loss in performance. Finally, we observe that if faulty nodes are allowed to communicate, but not compute, then an N-node one-dimensional array can tolerate logO(1) N worst-case faults and still emulate a fault-free array with constant slowdown, and this bound is tight.

Original languageEnglish (US)
Title of host publicationConference Proceedings of the Annual ACM Symposium on Theory of Computing
PublisherPubl by ACM
Pages561-572
Number of pages12
ISBN (Print)0897915917
StatePublished - 1993
EventProceedings of the 25th Annual ACM Symposium on the Theory of Computing - San Diego, CA, USA
Duration: May 16 1993May 18 1993

Other

OtherProceedings of the 25th Annual ACM Symposium on the Theory of Computing
CitySan Diego, CA, USA
Period5/16/935/18/93

ASJC Scopus subject areas

  • Software

Cite this

Cole, R., Maggs, B., & Sitaraman, R. (1993). Multi-scale self-simulation: A technique for reconfiguring arrays with faults. In Conference Proceedings of the Annual ACM Symposium on Theory of Computing (pp. 561-572). Publ by ACM.

Multi-scale self-simulation : A technique for reconfiguring arrays with faults. / Cole, Richard; Maggs, Bruce; Sitaraman, Ramesh.

Conference Proceedings of the Annual ACM Symposium on Theory of Computing. Publ by ACM, 1993. p. 561-572.

Research output: Chapter in Book/Report/Conference proceedingConference contribution

Cole, R, Maggs, B & Sitaraman, R 1993, Multi-scale self-simulation: A technique for reconfiguring arrays with faults. in Conference Proceedings of the Annual ACM Symposium on Theory of Computing. Publ by ACM, pp. 561-572, Proceedings of the 25th Annual ACM Symposium on the Theory of Computing, San Diego, CA, USA, 5/16/93.
Cole R, Maggs B, Sitaraman R. Multi-scale self-simulation: A technique for reconfiguring arrays with faults. In Conference Proceedings of the Annual ACM Symposium on Theory of Computing. Publ by ACM. 1993. p. 561-572
Cole, Richard ; Maggs, Bruce ; Sitaraman, Ramesh. / Multi-scale self-simulation : A technique for reconfiguring arrays with faults. Conference Proceedings of the Annual ACM Symposium on Theory of Computing. Publ by ACM, 1993. pp. 561-572
@inproceedings{224f1e14c113484bbf120263d5d0c377,
title = "Multi-scale self-simulation: A technique for reconfiguring arrays with faults",
abstract = "In this paper we study the ability of array-based networks to tolerate faults. We show that an N×N two-dimensional array can sustain N1-ε worst-case faults, for any fixed ε>0, and still emulate a fully functioning N×N array with only constant slowdown. We also observe that even if every node fails with some fixed probability, p, with high probability the array can still emulate a fully functioning array with constant slowdown. Previously, no connected bounded-degree network was known to be able to tolerate constant-probability node failures without suffering more than a constant-factor loss in performance. Finally, we observe that if faulty nodes are allowed to communicate, but not compute, then an N-node one-dimensional array can tolerate logO(1) N worst-case faults and still emulate a fault-free array with constant slowdown, and this bound is tight.",
author = "Richard Cole and Bruce Maggs and Ramesh Sitaraman",
year = "1993",
language = "English (US)",
isbn = "0897915917",
pages = "561--572",
booktitle = "Conference Proceedings of the Annual ACM Symposium on Theory of Computing",
publisher = "Publ by ACM",

}

TY - GEN

T1 - Multi-scale self-simulation

T2 - A technique for reconfiguring arrays with faults

AU - Cole, Richard

AU - Maggs, Bruce

AU - Sitaraman, Ramesh

PY - 1993

Y1 - 1993

N2 - In this paper we study the ability of array-based networks to tolerate faults. We show that an N×N two-dimensional array can sustain N1-ε worst-case faults, for any fixed ε>0, and still emulate a fully functioning N×N array with only constant slowdown. We also observe that even if every node fails with some fixed probability, p, with high probability the array can still emulate a fully functioning array with constant slowdown. Previously, no connected bounded-degree network was known to be able to tolerate constant-probability node failures without suffering more than a constant-factor loss in performance. Finally, we observe that if faulty nodes are allowed to communicate, but not compute, then an N-node one-dimensional array can tolerate logO(1) N worst-case faults and still emulate a fault-free array with constant slowdown, and this bound is tight.

AB - In this paper we study the ability of array-based networks to tolerate faults. We show that an N×N two-dimensional array can sustain N1-ε worst-case faults, for any fixed ε>0, and still emulate a fully functioning N×N array with only constant slowdown. We also observe that even if every node fails with some fixed probability, p, with high probability the array can still emulate a fully functioning array with constant slowdown. Previously, no connected bounded-degree network was known to be able to tolerate constant-probability node failures without suffering more than a constant-factor loss in performance. Finally, we observe that if faulty nodes are allowed to communicate, but not compute, then an N-node one-dimensional array can tolerate logO(1) N worst-case faults and still emulate a fault-free array with constant slowdown, and this bound is tight.

UR - http://www.scopus.com/inward/record.url?scp=0027188173&partnerID=8YFLogxK

UR - http://www.scopus.com/inward/citedby.url?scp=0027188173&partnerID=8YFLogxK

M3 - Conference contribution

AN - SCOPUS:0027188173

SN - 0897915917

SP - 561

EP - 572

BT - Conference Proceedings of the Annual ACM Symposium on Theory of Computing

PB - Publ by ACM

ER -