GPU‐based branch‐and‐bound method to solve large 0‐1 knapsack problems with data‐centric strategies

Summary An out‐of‐core branch‐and‐bound (B&B) method to solve large 0‐1 knapsack problems on a graphics processing unit (GPU) is proposed. Given a large problem that produces many subproblems, the proposed method dynamically swaps subproblems to CPU memory. Because such a CPU‐centric subproblem...

Ausführliche Beschreibung

Gespeichert in:
Bibliographische Detailangaben
Veröffentlicht in:Concurrency and computation 2019-02, Vol.31 (4), p.n/a
Hauptverfasser: Shen, Jingcheng, Shigeoka, Kentaro, Ino, Fumihiko, Hagihara, Kenichi
Format: Artikel
Sprache:eng
Schlagworte:
Online-Zugang:Volltext
Tags: Tag hinzufügen
Keine Tags, Fügen Sie den ersten Tag hinzu!
container_end_page n/a
container_issue 4
container_start_page
container_title Concurrency and computation
container_volume 31
creator Shen, Jingcheng
Shigeoka, Kentaro
Ino, Fumihiko
Hagihara, Kenichi
description Summary An out‐of‐core branch‐and‐bound (B&B) method to solve large 0‐1 knapsack problems on a graphics processing unit (GPU) is proposed. Given a large problem that produces many subproblems, the proposed method dynamically swaps subproblems to CPU memory. Because such a CPU‐centric subproblem management scheme increases CPU‐GPU data transfer, we adopt three data‐centric strategies to eliminate this side effect. The first is an out‐of‐order search (O3S) strategy that reduces the data transfer overhead by adaptively transferring subproblems between the CPU and GPU. The second is an explicitly‐managed pipelining strategy that hides the data transfer overhead by overlapping data transfer with GPU‐based B&B operations. The third is a GPU‐based stream compaction strategy that reduces the sparseness of arrays to be transferred. Experimental results demonstrate that the proposed out‐of‐core method stored 41 times as many subproblems as a previous in‐core method that manages subproblems in GPU memory, solving approximately twice as many problem instances on the GPU. In addition, compared to a previous breadth‐first search (BFS) strategy, the proposed O3S strategy achieved an average speedup of 7.5 times.
doi_str_mv 10.1002/cpe.4954
format Article
fullrecord <record><control><sourceid>proquest_cross</sourceid><recordid>TN_cdi_proquest_journals_2166032905</recordid><sourceformat>XML</sourceformat><sourcesystem>PC</sourcesystem><sourcerecordid>2166032905</sourcerecordid><originalsourceid>FETCH-LOGICAL-c2934-47e70390f9d24473d5df5aa04d3cb6614e0f0e9cc7daeb937b929e55a4856ad53</originalsourceid><addsrcrecordid>eNp1kE1OwzAQhS0EEqUgcQRLbNik-DfBS1SVglSJLujacuxJmzZNgu1SdccROCMnIaGIHav5eZ_mjR5C15SMKCHszrYwEkqKEzSgkrOEpFyc_vUsPUcXIawJoZRwOkDb6Xzx9fGZmwAO597UdtWNpnb9stnVDm8hrhqHY4NDU70DroxfAiadTvGmNm0wdoNb3-QVbAPel3GFnYmm0y3U0ZcWh-hNhGUJ4RKdFaYKcPVbh2jxOHkdPyWzl-nz-GGWWKa4SEQGGeGKFMoxITLupCukMUQ4bvM0pQJIQUBZmzkDueJZrpgCKY24l6lxkg_RzfFu99fbDkLU62bn685SM5qmhDNFeur2SFnfhOCh0K0vt8YfNCW6D1N3Yeo-zA5Njui-rODwL6fH88kP_w2bA3qV</addsrcrecordid><sourcetype>Aggregation Database</sourcetype><iscdi>true</iscdi><recordtype>article</recordtype><pqid>2166032905</pqid></control><display><type>article</type><title>GPU‐based branch‐and‐bound method to solve large 0‐1 knapsack problems with data‐centric strategies</title><source>Wiley Online Library Journals Frontfile Complete</source><creator>Shen, Jingcheng ; Shigeoka, Kentaro ; Ino, Fumihiko ; Hagihara, Kenichi</creator><creatorcontrib>Shen, Jingcheng ; Shigeoka, Kentaro ; Ino, Fumihiko ; Hagihara, Kenichi</creatorcontrib><description>Summary An out‐of‐core branch‐and‐bound (B&amp;B) method to solve large 0‐1 knapsack problems on a graphics processing unit (GPU) is proposed. Given a large problem that produces many subproblems, the proposed method dynamically swaps subproblems to CPU memory. Because such a CPU‐centric subproblem management scheme increases CPU‐GPU data transfer, we adopt three data‐centric strategies to eliminate this side effect. The first is an out‐of‐order search (O3S) strategy that reduces the data transfer overhead by adaptively transferring subproblems between the CPU and GPU. The second is an explicitly‐managed pipelining strategy that hides the data transfer overhead by overlapping data transfer with GPU‐based B&amp;B operations. The third is a GPU‐based stream compaction strategy that reduces the sparseness of arrays to be transferred. Experimental results demonstrate that the proposed out‐of‐core method stored 41 times as many subproblems as a previous in‐core method that manages subproblems in GPU memory, solving approximately twice as many problem instances on the GPU. In addition, compared to a previous breadth‐first search (BFS) strategy, the proposed O3S strategy achieved an average speedup of 7.5 times.</description><identifier>ISSN: 1532-0626</identifier><identifier>EISSN: 1532-0634</identifier><identifier>DOI: 10.1002/cpe.4954</identifier><language>eng</language><publisher>Hoboken: Wiley Subscription Services, Inc</publisher><subject>branch and bound ; Branch and bound methods ; Data transfer (computers) ; data‐centric method ; GPU ; Graphics processing units ; knapsack ; out‐of‐core computation ; Pipelining (computers) ; Strategy</subject><ispartof>Concurrency and computation, 2019-02, Vol.31 (4), p.n/a</ispartof><rights>2018 John Wiley &amp; Sons, Ltd.</rights><rights>2019 John Wiley &amp; Sons, Ltd.</rights><lds50>peer_reviewed</lds50><woscitedreferencessubscribed>false</woscitedreferencessubscribed><citedby>FETCH-LOGICAL-c2934-47e70390f9d24473d5df5aa04d3cb6614e0f0e9cc7daeb937b929e55a4856ad53</citedby><cites>FETCH-LOGICAL-c2934-47e70390f9d24473d5df5aa04d3cb6614e0f0e9cc7daeb937b929e55a4856ad53</cites><orcidid>0000-0002-2090-159X</orcidid></display><links><openurl>$$Topenurl_article</openurl><openurlfulltext>$$Topenurlfull_article</openurlfulltext><thumbnail>$$Tsyndetics_thumb_exl</thumbnail><linktopdf>$$Uhttps://onlinelibrary.wiley.com/doi/pdf/10.1002%2Fcpe.4954$$EPDF$$P50$$Gwiley$$H</linktopdf><linktohtml>$$Uhttps://onlinelibrary.wiley.com/doi/full/10.1002%2Fcpe.4954$$EHTML$$P50$$Gwiley$$H</linktohtml><link.rule.ids>314,778,782,1414,27911,27912,45561,45562</link.rule.ids></links><search><creatorcontrib>Shen, Jingcheng</creatorcontrib><creatorcontrib>Shigeoka, Kentaro</creatorcontrib><creatorcontrib>Ino, Fumihiko</creatorcontrib><creatorcontrib>Hagihara, Kenichi</creatorcontrib><title>GPU‐based branch‐and‐bound method to solve large 0‐1 knapsack problems with data‐centric strategies</title><title>Concurrency and computation</title><description>Summary An out‐of‐core branch‐and‐bound (B&amp;B) method to solve large 0‐1 knapsack problems on a graphics processing unit (GPU) is proposed. Given a large problem that produces many subproblems, the proposed method dynamically swaps subproblems to CPU memory. Because such a CPU‐centric subproblem management scheme increases CPU‐GPU data transfer, we adopt three data‐centric strategies to eliminate this side effect. The first is an out‐of‐order search (O3S) strategy that reduces the data transfer overhead by adaptively transferring subproblems between the CPU and GPU. The second is an explicitly‐managed pipelining strategy that hides the data transfer overhead by overlapping data transfer with GPU‐based B&amp;B operations. The third is a GPU‐based stream compaction strategy that reduces the sparseness of arrays to be transferred. Experimental results demonstrate that the proposed out‐of‐core method stored 41 times as many subproblems as a previous in‐core method that manages subproblems in GPU memory, solving approximately twice as many problem instances on the GPU. In addition, compared to a previous breadth‐first search (BFS) strategy, the proposed O3S strategy achieved an average speedup of 7.5 times.</description><subject>branch and bound</subject><subject>Branch and bound methods</subject><subject>Data transfer (computers)</subject><subject>data‐centric method</subject><subject>GPU</subject><subject>Graphics processing units</subject><subject>knapsack</subject><subject>out‐of‐core computation</subject><subject>Pipelining (computers)</subject><subject>Strategy</subject><issn>1532-0626</issn><issn>1532-0634</issn><fulltext>true</fulltext><rsrctype>article</rsrctype><creationdate>2019</creationdate><recordtype>article</recordtype><recordid>eNp1kE1OwzAQhS0EEqUgcQRLbNik-DfBS1SVglSJLujacuxJmzZNgu1SdccROCMnIaGIHav5eZ_mjR5C15SMKCHszrYwEkqKEzSgkrOEpFyc_vUsPUcXIawJoZRwOkDb6Xzx9fGZmwAO597UdtWNpnb9stnVDm8hrhqHY4NDU70DroxfAiadTvGmNm0wdoNb3-QVbAPel3GFnYmm0y3U0ZcWh-hNhGUJ4RKdFaYKcPVbh2jxOHkdPyWzl-nz-GGWWKa4SEQGGeGKFMoxITLupCukMUQ4bvM0pQJIQUBZmzkDueJZrpgCKY24l6lxkg_RzfFu99fbDkLU62bn685SM5qmhDNFeur2SFnfhOCh0K0vt8YfNCW6D1N3Yeo-zA5Njui-rODwL6fH88kP_w2bA3qV</recordid><startdate>20190225</startdate><enddate>20190225</enddate><creator>Shen, Jingcheng</creator><creator>Shigeoka, Kentaro</creator><creator>Ino, Fumihiko</creator><creator>Hagihara, Kenichi</creator><general>Wiley Subscription Services, Inc</general><scope>AAYXX</scope><scope>CITATION</scope><scope>7SC</scope><scope>8FD</scope><scope>JQ2</scope><scope>L7M</scope><scope>L~C</scope><scope>L~D</scope><orcidid>https://orcid.org/0000-0002-2090-159X</orcidid></search><sort><creationdate>20190225</creationdate><title>GPU‐based branch‐and‐bound method to solve large 0‐1 knapsack problems with data‐centric strategies</title><author>Shen, Jingcheng ; Shigeoka, Kentaro ; Ino, Fumihiko ; Hagihara, Kenichi</author></sort><facets><frbrtype>5</frbrtype><frbrgroupid>cdi_FETCH-LOGICAL-c2934-47e70390f9d24473d5df5aa04d3cb6614e0f0e9cc7daeb937b929e55a4856ad53</frbrgroupid><rsrctype>articles</rsrctype><prefilter>articles</prefilter><language>eng</language><creationdate>2019</creationdate><topic>branch and bound</topic><topic>Branch and bound methods</topic><topic>Data transfer (computers)</topic><topic>data‐centric method</topic><topic>GPU</topic><topic>Graphics processing units</topic><topic>knapsack</topic><topic>out‐of‐core computation</topic><topic>Pipelining (computers)</topic><topic>Strategy</topic><toplevel>peer_reviewed</toplevel><toplevel>online_resources</toplevel><creatorcontrib>Shen, Jingcheng</creatorcontrib><creatorcontrib>Shigeoka, Kentaro</creatorcontrib><creatorcontrib>Ino, Fumihiko</creatorcontrib><creatorcontrib>Hagihara, Kenichi</creatorcontrib><collection>CrossRef</collection><collection>Computer and Information Systems Abstracts</collection><collection>Technology Research Database</collection><collection>ProQuest Computer Science Collection</collection><collection>Advanced Technologies Database with Aerospace</collection><collection>Computer and Information Systems Abstracts – Academic</collection><collection>Computer and Information Systems Abstracts Professional</collection><jtitle>Concurrency and computation</jtitle></facets><delivery><delcategory>Remote Search Resource</delcategory><fulltext>fulltext</fulltext></delivery><addata><au>Shen, Jingcheng</au><au>Shigeoka, Kentaro</au><au>Ino, Fumihiko</au><au>Hagihara, Kenichi</au><format>journal</format><genre>article</genre><ristype>JOUR</ristype><atitle>GPU‐based branch‐and‐bound method to solve large 0‐1 knapsack problems with data‐centric strategies</atitle><jtitle>Concurrency and computation</jtitle><date>2019-02-25</date><risdate>2019</risdate><volume>31</volume><issue>4</issue><epage>n/a</epage><issn>1532-0626</issn><eissn>1532-0634</eissn><abstract>Summary An out‐of‐core branch‐and‐bound (B&amp;B) method to solve large 0‐1 knapsack problems on a graphics processing unit (GPU) is proposed. Given a large problem that produces many subproblems, the proposed method dynamically swaps subproblems to CPU memory. Because such a CPU‐centric subproblem management scheme increases CPU‐GPU data transfer, we adopt three data‐centric strategies to eliminate this side effect. The first is an out‐of‐order search (O3S) strategy that reduces the data transfer overhead by adaptively transferring subproblems between the CPU and GPU. The second is an explicitly‐managed pipelining strategy that hides the data transfer overhead by overlapping data transfer with GPU‐based B&amp;B operations. The third is a GPU‐based stream compaction strategy that reduces the sparseness of arrays to be transferred. Experimental results demonstrate that the proposed out‐of‐core method stored 41 times as many subproblems as a previous in‐core method that manages subproblems in GPU memory, solving approximately twice as many problem instances on the GPU. In addition, compared to a previous breadth‐first search (BFS) strategy, the proposed O3S strategy achieved an average speedup of 7.5 times.</abstract><cop>Hoboken</cop><pub>Wiley Subscription Services, Inc</pub><doi>10.1002/cpe.4954</doi><tpages>1</tpages><orcidid>https://orcid.org/0000-0002-2090-159X</orcidid></addata></record>
fulltext fulltext
identifier ISSN: 1532-0626
ispartof Concurrency and computation, 2019-02, Vol.31 (4), p.n/a
issn 1532-0626
1532-0634
language eng
recordid cdi_proquest_journals_2166032905
source Wiley Online Library Journals Frontfile Complete
subjects branch and bound
Branch and bound methods
Data transfer (computers)
data‐centric method
GPU
Graphics processing units
knapsack
out‐of‐core computation
Pipelining (computers)
Strategy
title GPU‐based branch‐and‐bound method to solve large 0‐1 knapsack problems with data‐centric strategies
url https://sfx.bib-bvb.de/sfx_tum?ctx_ver=Z39.88-2004&ctx_enc=info:ofi/enc:UTF-8&ctx_tim=2025-01-15T10%3A35%3A41IST&url_ver=Z39.88-2004&url_ctx_fmt=infofi/fmt:kev:mtx:ctx&rfr_id=info:sid/primo.exlibrisgroup.com:primo3-Article-proquest_cross&rft_val_fmt=info:ofi/fmt:kev:mtx:journal&rft.genre=article&rft.atitle=GPU%E2%80%90based%20branch%E2%80%90and%E2%80%90bound%20method%20to%20solve%20large%200%E2%80%901%20knapsack%20problems%20with%20data%E2%80%90centric%20strategies&rft.jtitle=Concurrency%20and%20computation&rft.au=Shen,%20Jingcheng&rft.date=2019-02-25&rft.volume=31&rft.issue=4&rft.epage=n/a&rft.issn=1532-0626&rft.eissn=1532-0634&rft_id=info:doi/10.1002/cpe.4954&rft_dat=%3Cproquest_cross%3E2166032905%3C/proquest_cross%3E%3Curl%3E%3C/url%3E&disable_directlink=true&sfx.directlink=off&sfx.report_link=0&rft_id=info:oai/&rft_pqid=2166032905&rft_id=info:pmid/&rfr_iscdi=true