Counting in One-Hop Beeping Networks
We consider networks of processes which interact with beeps. In the basic model defined by Cornejo and Kuhn, which we refer to as the $BL$ variant, processes can choose in each round either to beep or to listen. Those who beep are unable to detect simultaneous beeps. Those who listen can only distin...
Gespeichert in:
Hauptverfasser: | , , , |
---|---|
Format: | Artikel |
Sprache: | eng |
Schlagworte: | |
Online-Zugang: | Volltext bestellen |
Tags: |
Tag hinzufügen
Keine Tags, Fügen Sie den ersten Tag hinzu!
|
container_end_page | |
---|---|
container_issue | |
container_start_page | |
container_title | |
container_volume | |
creator | Casteigts, A Métivier, Y Robson, J. M Zemmari, A |
description | We consider networks of processes which interact with beeps. In the basic
model defined by Cornejo and Kuhn, which we refer to as the $BL$ variant,
processes can choose in each round either to beep or to listen. Those who beep
are unable to detect simultaneous beeps. Those who listen can only distinguish
between silence and the presence of at least one beep. Beeping models are weak
in essence and even simple tasks may become difficult or unfeasible with them.
In this paper, we address the problem of computing how many participants
there are in a one-hop network: the {\em counting} problem. We first observe
that no algorithm can compute this number with certainty in $BL$, whether the
algorithm be deterministic or even randomised (Las Vegas). We thus consider the
stronger variant where beeping nodes are able to detect simultaneous beeps,
referred to as $B_{cd}L$ (for {\em collision detection}). We prove that at
least $n$ rounds are necessary in $B_{cd}L$, and we present an algorithm whose
running time is $O(n)$ rounds with high probability. Further experimental
results show that its expected running time is less than $10n$. Finally, we
discuss how this algorithm can be adapted in other beeping models. In
particular, we show that it can be emulated in $BL$, at the cost of a
logarithmic slowdown and of trading its Las Vegas nature (result certain, time
uncertain) against Monte Carlo (time certain, result uncertain). |
doi_str_mv | 10.48550/arxiv.1605.09516 |
format | Article |
fullrecord | <record><control><sourceid>arxiv_GOX</sourceid><recordid>TN_cdi_arxiv_primary_1605_09516</recordid><sourceformat>XML</sourceformat><sourcesystem>PC</sourcesystem><sourcerecordid>1605_09516</sourcerecordid><originalsourceid>FETCH-LOGICAL-a676-fc31d0e7da22b9cab3a3a22ed0938d9d216c9804ed8bc736b570d48f916e1fec3</originalsourceid><addsrcrecordid>eNotzj0PgjAYBOAuDgb9AU4yuIItpaUdlaiYEFnYSWlfDFGBAH79ewWd7nLD5UFoQbDrC8bwWrWv8uESjpmLJSN8ilZhfa_6sjrbZWUnFThR3dhbgGaYTtA_6_bSzdCkUNcO5v-0ULrfpWHkxMnhGG5iR_GAO4WmxGAIjPK8XGqVU0W_FQyWVBhpPMK1FNgHI3IdUJ6zABtfFJJwIAVoaqHl73ZkZk1b3lT7zgZuNnLpB6QdOZg</addsrcrecordid><sourcetype>Open Access Repository</sourcetype><iscdi>true</iscdi><recordtype>article</recordtype></control><display><type>article</type><title>Counting in One-Hop Beeping Networks</title><source>arXiv.org</source><creator>Casteigts, A ; Métivier, Y ; Robson, J. M ; Zemmari, A</creator><creatorcontrib>Casteigts, A ; Métivier, Y ; Robson, J. M ; Zemmari, A</creatorcontrib><description>We consider networks of processes which interact with beeps. In the basic
model defined by Cornejo and Kuhn, which we refer to as the $BL$ variant,
processes can choose in each round either to beep or to listen. Those who beep
are unable to detect simultaneous beeps. Those who listen can only distinguish
between silence and the presence of at least one beep. Beeping models are weak
in essence and even simple tasks may become difficult or unfeasible with them.
In this paper, we address the problem of computing how many participants
there are in a one-hop network: the {\em counting} problem. We first observe
that no algorithm can compute this number with certainty in $BL$, whether the
algorithm be deterministic or even randomised (Las Vegas). We thus consider the
stronger variant where beeping nodes are able to detect simultaneous beeps,
referred to as $B_{cd}L$ (for {\em collision detection}). We prove that at
least $n$ rounds are necessary in $B_{cd}L$, and we present an algorithm whose
running time is $O(n)$ rounds with high probability. Further experimental
results show that its expected running time is less than $10n$. Finally, we
discuss how this algorithm can be adapted in other beeping models. In
particular, we show that it can be emulated in $BL$, at the cost of a
logarithmic slowdown and of trading its Las Vegas nature (result certain, time
uncertain) against Monte Carlo (time certain, result uncertain).</description><identifier>DOI: 10.48550/arxiv.1605.09516</identifier><language>eng</language><subject>Computer Science - Distributed, Parallel, and Cluster Computing</subject><creationdate>2016-05</creationdate><rights>http://arxiv.org/licenses/nonexclusive-distrib/1.0</rights><oa>free_for_read</oa><woscitedreferencessubscribed>false</woscitedreferencessubscribed></display><links><openurl>$$Topenurl_article</openurl><openurlfulltext>$$Topenurlfull_article</openurlfulltext><thumbnail>$$Tsyndetics_thumb_exl</thumbnail><link.rule.ids>228,230,776,881</link.rule.ids><linktorsrc>$$Uhttps://arxiv.org/abs/1605.09516$$EView_record_in_Cornell_University$$FView_record_in_$$GCornell_University$$Hfree_for_read</linktorsrc><backlink>$$Uhttps://doi.org/10.48550/arXiv.1605.09516$$DView paper in arXiv$$Hfree_for_read</backlink></links><search><creatorcontrib>Casteigts, A</creatorcontrib><creatorcontrib>Métivier, Y</creatorcontrib><creatorcontrib>Robson, J. M</creatorcontrib><creatorcontrib>Zemmari, A</creatorcontrib><title>Counting in One-Hop Beeping Networks</title><description>We consider networks of processes which interact with beeps. In the basic
model defined by Cornejo and Kuhn, which we refer to as the $BL$ variant,
processes can choose in each round either to beep or to listen. Those who beep
are unable to detect simultaneous beeps. Those who listen can only distinguish
between silence and the presence of at least one beep. Beeping models are weak
in essence and even simple tasks may become difficult or unfeasible with them.
In this paper, we address the problem of computing how many participants
there are in a one-hop network: the {\em counting} problem. We first observe
that no algorithm can compute this number with certainty in $BL$, whether the
algorithm be deterministic or even randomised (Las Vegas). We thus consider the
stronger variant where beeping nodes are able to detect simultaneous beeps,
referred to as $B_{cd}L$ (for {\em collision detection}). We prove that at
least $n$ rounds are necessary in $B_{cd}L$, and we present an algorithm whose
running time is $O(n)$ rounds with high probability. Further experimental
results show that its expected running time is less than $10n$. Finally, we
discuss how this algorithm can be adapted in other beeping models. In
particular, we show that it can be emulated in $BL$, at the cost of a
logarithmic slowdown and of trading its Las Vegas nature (result certain, time
uncertain) against Monte Carlo (time certain, result uncertain).</description><subject>Computer Science - Distributed, Parallel, and Cluster Computing</subject><fulltext>true</fulltext><rsrctype>article</rsrctype><creationdate>2016</creationdate><recordtype>article</recordtype><sourceid>GOX</sourceid><recordid>eNotzj0PgjAYBOAuDgb9AU4yuIItpaUdlaiYEFnYSWlfDFGBAH79ewWd7nLD5UFoQbDrC8bwWrWv8uESjpmLJSN8ilZhfa_6sjrbZWUnFThR3dhbgGaYTtA_6_bSzdCkUNcO5v-0ULrfpWHkxMnhGG5iR_GAO4WmxGAIjPK8XGqVU0W_FQyWVBhpPMK1FNgHI3IdUJ6zABtfFJJwIAVoaqHl73ZkZk1b3lT7zgZuNnLpB6QdOZg</recordid><startdate>20160531</startdate><enddate>20160531</enddate><creator>Casteigts, A</creator><creator>Métivier, Y</creator><creator>Robson, J. M</creator><creator>Zemmari, A</creator><scope>AKY</scope><scope>GOX</scope></search><sort><creationdate>20160531</creationdate><title>Counting in One-Hop Beeping Networks</title><author>Casteigts, A ; Métivier, Y ; Robson, J. M ; Zemmari, A</author></sort><facets><frbrtype>5</frbrtype><frbrgroupid>cdi_FETCH-LOGICAL-a676-fc31d0e7da22b9cab3a3a22ed0938d9d216c9804ed8bc736b570d48f916e1fec3</frbrgroupid><rsrctype>articles</rsrctype><prefilter>articles</prefilter><language>eng</language><creationdate>2016</creationdate><topic>Computer Science - Distributed, Parallel, and Cluster Computing</topic><toplevel>online_resources</toplevel><creatorcontrib>Casteigts, A</creatorcontrib><creatorcontrib>Métivier, Y</creatorcontrib><creatorcontrib>Robson, J. M</creatorcontrib><creatorcontrib>Zemmari, A</creatorcontrib><collection>arXiv Computer Science</collection><collection>arXiv.org</collection></facets><delivery><delcategory>Remote Search Resource</delcategory><fulltext>fulltext_linktorsrc</fulltext></delivery><addata><au>Casteigts, A</au><au>Métivier, Y</au><au>Robson, J. M</au><au>Zemmari, A</au><format>journal</format><genre>article</genre><ristype>JOUR</ristype><atitle>Counting in One-Hop Beeping Networks</atitle><date>2016-05-31</date><risdate>2016</risdate><abstract>We consider networks of processes which interact with beeps. In the basic
model defined by Cornejo and Kuhn, which we refer to as the $BL$ variant,
processes can choose in each round either to beep or to listen. Those who beep
are unable to detect simultaneous beeps. Those who listen can only distinguish
between silence and the presence of at least one beep. Beeping models are weak
in essence and even simple tasks may become difficult or unfeasible with them.
In this paper, we address the problem of computing how many participants
there are in a one-hop network: the {\em counting} problem. We first observe
that no algorithm can compute this number with certainty in $BL$, whether the
algorithm be deterministic or even randomised (Las Vegas). We thus consider the
stronger variant where beeping nodes are able to detect simultaneous beeps,
referred to as $B_{cd}L$ (for {\em collision detection}). We prove that at
least $n$ rounds are necessary in $B_{cd}L$, and we present an algorithm whose
running time is $O(n)$ rounds with high probability. Further experimental
results show that its expected running time is less than $10n$. Finally, we
discuss how this algorithm can be adapted in other beeping models. In
particular, we show that it can be emulated in $BL$, at the cost of a
logarithmic slowdown and of trading its Las Vegas nature (result certain, time
uncertain) against Monte Carlo (time certain, result uncertain).</abstract><doi>10.48550/arxiv.1605.09516</doi><oa>free_for_read</oa></addata></record> |
fulltext | fulltext_linktorsrc |
identifier | DOI: 10.48550/arxiv.1605.09516 |
ispartof | |
issn | |
language | eng |
recordid | cdi_arxiv_primary_1605_09516 |
source | arXiv.org |
subjects | Computer Science - Distributed, Parallel, and Cluster Computing |
title | Counting in One-Hop Beeping Networks |
url | https://sfx.bib-bvb.de/sfx_tum?ctx_ver=Z39.88-2004&ctx_enc=info:ofi/enc:UTF-8&ctx_tim=2025-02-07T04%3A52%3A30IST&url_ver=Z39.88-2004&url_ctx_fmt=infofi/fmt:kev:mtx:ctx&rfr_id=info:sid/primo.exlibrisgroup.com:primo3-Article-arxiv_GOX&rft_val_fmt=info:ofi/fmt:kev:mtx:journal&rft.genre=article&rft.atitle=Counting%20in%20One-Hop%20Beeping%20Networks&rft.au=Casteigts,%20A&rft.date=2016-05-31&rft_id=info:doi/10.48550/arxiv.1605.09516&rft_dat=%3Carxiv_GOX%3E1605_09516%3C/arxiv_GOX%3E%3Curl%3E%3C/url%3E&disable_directlink=true&sfx.directlink=off&sfx.report_link=0&rft_id=info:oai/&rft_id=info:pmid/&rfr_iscdi=true |