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...
Gespeichert in:
Veröffentlicht in: | Concurrency and computation 2019-02, Vol.31 (4), p.n/a |
---|---|
Hauptverfasser: | , , , |
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&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.</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 & Sons, Ltd.</rights><rights>2019 John Wiley & 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&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.</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&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.</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 |