10 Years of research on debugging concurrent and multicore software: a systematic mapping study
Debugging—the process of identifying, localizing and fixing bugs—is a key activity in software development . Due to issues such as non-determinism and difficulties of reproducing failures, debugging concurrent software is significantly more challenging than debugging sequential software. A number of...
Uloženo v:
| Vydáno v: | Software quality journal Ročník 25; číslo 1; s. 49 - 82 |
|---|---|
| Hlavní autoři: | , , , , |
| Médium: | Journal Article |
| Jazyk: | angličtina |
| Vydáno: |
New York
Springer US
01.03.2017
Springer Nature B.V |
| Témata: | |
| ISSN: | 0963-9314, 1573-1367, 1573-1367 |
| On-line přístup: | Získat plný text |
| Tagy: |
Přidat tag
Žádné tagy, Buďte první, kdo vytvoří štítek k tomuto záznamu!
|
| Abstract | Debugging—the process of identifying, localizing and fixing bugs—is a key activity in software development . Due to issues such as non-determinism and difficulties of reproducing failures, debugging concurrent software is significantly more challenging than debugging sequential software. A number of methods, models and tools for debugging concurrent and multicore software have been proposed, but the body of work partially lacks a common terminology and a more recent view of the problems to solve. This suggests the need for a classification, and an up-to-date comprehensive overview of the area. This paper presents the results of a systematic mapping study in the field of debugging of concurrent and multicore software in the last decade (2005–2014). The study is guided by two objectives: (1) to summarize the recent publication trends and (2) to clarify current research gaps in the field. Through a multi-stage selection process, we identified 145 relevant papers. Based on these, we summarize the publication trend in the field by showing distribution of publications with respect to
year
,
publication venues
,
representation of academia and industry
, and
active research institutes
. We also identify research gaps in the field based on attributes such as
types of concurrency bugs
,
types of debugging processes
,
types of research
and
research contributions
. The main observations from the study are that during the years 2005–2014: (1) there is no focal conference or venue to publish papers in this area; hence, a large variety of conferences and journal venues (90) are used to publish relevant papers in this area; (2) in terms of publication contribution, academia was more active in this area than industry; (3) most publications in the field address the data race bug; (4) bug identification is the most common stage of debugging addressed by articles in the period; (5) there are six types of research approaches found, with solution proposals being the most common one; and (6) the published papers essentially focus on four different types of contributions, with “methods” being the most common type. We can further conclude that there are still quite a number of aspects that are not sufficiently covered in the field, most notably including (1)
exploring correction
and
fixing bugs
in terms of debugging process; (2)
order violation
,
suspension
and
starvation
in terms of concurrency bugs; (3)
validation
and
evaluation research
in the matter of research type; (4)
metric
in terms of research contribution. It is clear that the concurrent, parallel and multicore software community needs broader studies in debugging. This systematic mapping study can help direct such efforts. |
|---|---|
| AbstractList | Debugging – the process of identifying, localizing and fixing bugs – is a key activity in software development. Due to issues such as non-determinism and difficulties of reproducing failures, debugging concurrent software is significantly more challenging than debugging sequential software. A number of methods, models and tools for debugging concurrent and multicore software have been proposed, but the body of work partially lacks a common terminology and a more recent view of the problems to solve. This suggests the need for a classification, and an up-to-date comprehensive overview of the area.
This paper presents the results of a systematic mapping study in the field of debugging of concurrent and multicore software in the last decade (2005– 2014). The study is guided by two objectives: (1) to summarize the recent publication trends and (2) to clarify current research gaps in the field.
Through a multi-stage selection process, we identified 145 relevant papers. Based on these, we summarize the publication trend in the field by showing distribution of publications with respect to year , publication venues , representation of academia and industry , and active research institutes . We also identify research gaps in the field based on attributes such as types of concurrency bugs, types of debugging processes , types of research and research contributions.
The main observations from the study are that during the years 2005–2014: (1) there is no focal conference or venue to publish papers in this area, hence a large variety of conferences and journal venues (90) are used to publish relevant papers in this area; (2) in terms of publication contribution, academia was more active in this area than industry; (3) most publications in the field address the data race bug; (4) bug identification is the most common stage of debugging addressed by articles in the period; (5) there are six types of research approaches found, with solution proposals being the most common one; and (6) the published papers essentially focus on four different types of contributions, with ”methods” being the type most common one.
We can further conclude that there is still quite a number of aspects that are not sufficiently covered in the field, most notably including (1) exploring correction and fixing bugs in terms of debugging process; (2) order violation, suspension and starvation in terms of concurrency bugs; (3) validation and evaluation research in the matter of research type; (4) metric in terms of research contribution. It is clear that the concurrent, parallel and multicore software community needs broader studies in debugging.This systematic mapping study can help direct such efforts. Debugging—the process of identifying, localizing and fixing bugs—is a key activity in software development . Due to issues such as non-determinism and difficulties of reproducing failures, debugging concurrent software is significantly more challenging than debugging sequential software. A number of methods, models and tools for debugging concurrent and multicore software have been proposed, but the body of work partially lacks a common terminology and a more recent view of the problems to solve. This suggests the need for a classification, and an up-to-date comprehensive overview of the area. This paper presents the results of a systematic mapping study in the field of debugging of concurrent and multicore software in the last decade (2005–2014). The study is guided by two objectives: (1) to summarize the recent publication trends and (2) to clarify current research gaps in the field. Through a multi-stage selection process, we identified 145 relevant papers. Based on these, we summarize the publication trend in the field by showing distribution of publications with respect to year , publication venues , representation of academia and industry , and active research institutes . We also identify research gaps in the field based on attributes such as types of concurrency bugs , types of debugging processes , types of research and research contributions . The main observations from the study are that during the years 2005–2014: (1) there is no focal conference or venue to publish papers in this area; hence, a large variety of conferences and journal venues (90) are used to publish relevant papers in this area; (2) in terms of publication contribution, academia was more active in this area than industry; (3) most publications in the field address the data race bug; (4) bug identification is the most common stage of debugging addressed by articles in the period; (5) there are six types of research approaches found, with solution proposals being the most common one; and (6) the published papers essentially focus on four different types of contributions, with “methods” being the most common type. We can further conclude that there are still quite a number of aspects that are not sufficiently covered in the field, most notably including (1) exploring correction and fixing bugs in terms of debugging process; (2) order violation , suspension and starvation in terms of concurrency bugs; (3) validation and evaluation research in the matter of research type; (4) metric in terms of research contribution. It is clear that the concurrent, parallel and multicore software community needs broader studies in debugging. This systematic mapping study can help direct such efforts. Debugging--the process of identifying, localizing and fixing bugs--is a key activity in software development . Due to issues such as non-determinism and difficulties of reproducing failures, debugging concurrent software is significantly more challenging than debugging sequential software. A number of methods, models and tools for debugging concurrent and multicore software have been proposed, but the body of work partially lacks a common terminology and a more recent view of the problems to solve. This suggests the need for a classification, and an up-to-date comprehensive overview of the area. This paper presents the results of a systematic mapping study in the field of debugging of concurrent and multicore software in the last decade (2005-2014). The study is guided by two objectives: (1) to summarize the recent publication trends and (2) to clarify current research gaps in the field. Through a multi-stage selection process, we identified 145 relevant papers. Based on these, we summarize the publication trend in the field by showing distribution of publications with respect to year, publication venues, representation of academia and industry, and active research institutes. We also identify research gaps in the field based on attributes such as types of concurrency bugs, types of debugging processes, types of research and research contributions. The main observations from the study are that during the years 2005-2014: (1) there is no focal conference or venue to publish papers in this area; hence, a large variety of conferences and journal venues (90) are used to publish relevant papers in this area; (2) in terms of publication contribution, academia was more active in this area than industry; (3) most publications in the field address the data race bug; (4) bug identification is the most common stage of debugging addressed by articles in the period; (5) there are six types of research approaches found, with solution proposals being the most common one; and (6) the published papers essentially focus on four different types of contributions, with "methods" being the most common type. We can further conclude that there are still quite a number of aspects that are not sufficiently covered in the field, most notably including (1) exploring correction and fixing bugs in terms of debugging process; (2) order violation, suspension and starvation in terms of concurrency bugs; (3) validation and evaluation research in the matter of research type; (4) metric in terms of research contribution. It is clear that the concurrent, parallel and multicore software community needs broader studies in debugging. This systematic mapping study can help direct such efforts. |
| Author | Hansson, Hans Abbaspour Asadollah, Sara Eldh, Sigrid Sundmark, Daniel Afzal, Wasif |
| Author_xml | – sequence: 1 givenname: Sara surname: Abbaspour Asadollah fullname: Abbaspour Asadollah, Sara email: sara.abbaspour@mdh.se organization: Mälardalen University – sequence: 2 givenname: Daniel surname: Sundmark fullname: Sundmark, Daniel organization: Mälardalen University – sequence: 3 givenname: Sigrid surname: Eldh fullname: Eldh, Sigrid organization: Mälardalen University, Ericsson AB – sequence: 4 givenname: Hans surname: Hansson fullname: Hansson, Hans organization: Mälardalen University – sequence: 5 givenname: Wasif surname: Afzal fullname: Afzal, Wasif organization: Mälardalen University |
| BackLink | https://urn.kb.se/resolve?urn=urn:nbn:se:mdh:diva-31419$$DView record from Swedish Publication Index (Mälardalens högskola) |
| BookMark | eNp9kc1q3TAQRkVJoTdpH6A7QTdd1K3GsiS7u5D0DwLZJIWuhK48chxsyZVkwn37ytwUSqBZSTDnSDPfnJITHzwS8hbYR2BMfUoANXQVA1F1nEGlXpAdCMUr4FKdkB3rJC8VaF6R05TuGdusZkc0MPoLTUw0OBoxlau9o8HTHvfrMIx-oDZ4u8aIPlPjezqvUx5tiEhTcPnBRPxMDU2HlHE2pUJnsyybl_LaH16Tl85MCd88nmfk9uuXm4vv1dX1tx8X51eV5a3MlTMOJaBALiRHwZUQsmtEa9sWrZS9E04ZqLGRLWON2rumFo3lFlzt2r61_Ix8OL6bHnBZ93qJ42ziQQcz6svx57kOcdBzf6dLBNAV_P0RX2L4vWLKeh6TxWkyHsOaNLRtA6DKZwV99wS9D2v0ZZhCyY5x1tUbpY6UjSGliE7bMZc4gs_RjFOJWW-J6-OedNmT3vakVTHhifm39-ec-nHawvoB4z89_Vf6A2kXprg |
| CitedBy_id | crossref_primary_10_1145_3539662 crossref_primary_10_1109_TSE_2018_2887384 crossref_primary_10_1109_ACCESS_2022_3229233 crossref_primary_10_1109_ACCESS_2017_2744677 crossref_primary_10_1109_TITS_2019_2949915 crossref_primary_10_1109_TSC_2019_2919823 |
| Cites_doi | 10.1145/2509136.2509510 10.1145/1837853.1693463 10.1145/2483760.2492395 10.1109/CIT.2008.4594684 10.1145/2642937.2642972 10.1109/APSEC.2012.134 10.1109/ICSMC.2005.1571136 10.1016/j.jss.2012.08.063 10.1145/2508148.2485978 10.1145/2451116.2451130 10.1145/2490301.2451129 10.1016/j.jocs.2013.12.002 10.1109/SC.2012.79 10.1109/NAS.2012.28 10.1145/2517327.2442553 10.1145/2666356.2594300 10.1145/1353536.1346323 10.1007/978-3-642-35600-1_24 10.1109/ISPASS.2011.5762737 10.1145/1368088.1368119 10.1145/1273463.1273469 10.1145/1961295.1950394 10.1145/1122971.1122993 10.1109/COMPSAC.2011.22 10.1007/978-3-642-15585-7_7 10.1007/978-3-540-73368-3_26 10.1109/ASE.2008.39 10.1109/ICSE.2012.6227184 10.1145/1629575.1629594 10.1145/1134285.1134336 10.1145/1394608.1382144 10.1109/GrC.2007.120 10.1007/978-3-319-11692-1_14 10.1145/1993316.1993544 10.1145/1453101.1453121 10.1109/COMPSAC.2009.105 10.1109/MC.2009.391 10.1002/cpe.2918 10.1145/1831708.1831740 10.1109/IPDPSW.2010.5470683 10.1007/978-3-642-04425-0_5 10.1145/1181309.1181315 10.1109/WAINA.2012.124 10.1016/j.parco.2010.09.002 10.1145/1321631.1321678 10.1016/j.infsof.2010.05.011 10.1109/IPDPS.2009.5161006 10.1109/DSN.2012.6263953 10.1145/2544173.2509519 10.1145/1866210.1866213 10.1145/1966445.1966465 10.1109/ICST.2008.38 10.1109/TSE.2006.1599419 10.3837/tiis.2014.03.014 10.1007/s10766-012-0237-2 10.1109/ICSM.2008.4658058 10.1145/2338967.2336809 10.1145/2517349.2522736 10.1109/ICST.2012.85 10.1145/2666356.2594311 10.1109/DDECS.2013.6549788 10.1145/2666356.2594315 10.1109/VISSOF.2011.6069456 10.1007/s10836-013-5355-2 10.1145/2134243.2134248 10.1145/1188455.1188674 10.1109/ROBOT.2007.363651 10.1109/CDC.2012.6426112 10.1145/2516775.2516818 10.1145/1610252.1610271 10.1109/ISIT.2011.6033810 10.1016/j.entcs.2007.04.001 10.1145/1707801.1706351 10.1109/MM.2010.14 10.1109/ISCA.2008.36 10.1145/1669112.1669181 10.1145/1735971.1736039 10.1109/DSN.2010.5544315 10.1109/HPCA.2012.6169039 10.1145/1145319.1145342 10.1145/2372251.2372257 10.1109/PDCAT.2010.86 10.1007/978-3-540-73940-1_24 10.1145/1816038.1815988 10.1145/1273647.1273651 10.1109/TPDS.2013.209 10.1007/s00766-005-0021-6 10.1109/IPDPS.2008.4536312 10.1109/TSE.2010.107 10.1007/978-3-642-20398-5_23 10.1145/1377492.1377495 10.1109/I-SPAN.2009.123 10.1145/2544173.2509538 10.1145/1639622.1639632 10.1007/s10009-013-0274-1 10.1007/978-3-642-17578-7_23 10.1109/TC.2010.254 10.1109/ICRAIE.2014.6909202 10.1016/j.entcs.2004.01.032 10.1109/TrustCom.2011.222 10.1007/978-3-540-72360-8_27 10.1145/2338967.2336808 10.1145/1735970.1736038 10.1145/1809028.1806625 10.1109/IPDPS.2014.76 10.1109/IPDPS.2009.5160941 10.1109/COMPSACW.2011.94 10.1016/j.jss.2013.10.056 10.1145/1639622.1639629 10.1145/1379022.1375584 10.1145/2451116.2451120 10.1145/1791194.1791203 10.1109/ICSE-COMPANION.2009.5071033 10.1109/SERE-C.2013.33 10.1145/2517327.2442537 10.1145/1287624.1287703 10.1145/1639622.1639627 10.1145/1147403.1147413 10.1145/263699.263717 10.1145/2370036.2145880 10.1109/HPCA.2007.346191 10.1016/j.infsof.2012.08.013 10.1007/978-3-642-17604-3_28 10.1145/2451116.2451128 10.1109/MIEL.2012.6222877 10.1145/2043556.2043590 10.1016/j.jlamp.2014.07.003 10.1145/2642937.2642943 10.1145/1639949.1640096 10.1109/HPCA.2006.1598132 10.1109/ICPPW.2012.83 10.14236/ewic/EASE2008.8 |
| ContentType | Journal Article |
| Copyright | Springer Science+Business Media New York 2016 Software Quality Journal is a copyright of Springer, 2017. |
| Copyright_xml | – notice: Springer Science+Business Media New York 2016 – notice: Software Quality Journal is a copyright of Springer, 2017. |
| DBID | AAYXX CITATION 3V. 7SC 7WY 7WZ 7XB 87Z 8AL 8AO 8FD 8FE 8FG 8FK 8FL 8G5 ABUWG AFKRA ARAPS AZQEC BENPR BEZIV BGLVJ CCPQU DWQXO FRNLG F~G GNUQQ GUQSH HCIFZ JQ2 K60 K6~ K7- L.- L.0 L7M L~C L~D M0C M0N M2O MBDVC P5Z P62 PHGZM PHGZT PKEHL PQBIZ PQBZA PQEST PQGLB PQQKQ PQUKI Q9U ADTPV AOWAS DF7 |
| DOI | 10.1007/s11219-015-9301-7 |
| DatabaseName | CrossRef ProQuest Central (Corporate) Computer and Information Systems Abstracts ABI/INFORM Collection ABI/INFORM Global (PDF only) ProQuest Central (purchase pre-March 2016) ABI/INFORM Collection Computing Database (Alumni Edition) ProQuest Pharma Collection Technology Research Database ProQuest SciTech Collection ProQuest Technology Collection ProQuest Central (Alumni) (purchase pre-March 2016) ABI/INFORM Collection (Alumni) Research Library ProQuest Central (Alumni) ProQuest Central UK/Ireland Health Research Premium Collection ProQuest Central Essentials ProQuest Central Business Premium Collection Technology collection ProQuest One Community College ProQuest Central Business Premium Collection (Alumni) ABI/INFORM Global (Corporate) ProQuest Central Student Research Library Prep SciTech Premium Collection ProQuest Computer Science Collection ProQuest Business Collection (Alumni Edition) ProQuest Business Collection Computer Science Database ABI/INFORM Professional Advanced ABI/INFORM Professional Standard Advanced Technologies Database with Aerospace Computer and Information Systems Abstracts Academic Computer and Information Systems Abstracts Professional ABI/INFORM Global (OCUL) Computing Database Research Library Research Library (Corporate) AAdvanced Technologies & Aerospace Database (subscription) ProQuest Advanced Technologies & Aerospace Collection ProQuest Central Premium ProQuest One Academic ProQuest One Academic Middle East (New) ProQuest One Business ProQuest One Business (Alumni) ProQuest One Academic Eastern Edition (DO NOT USE) ProQuest One Applied & Life Sciences ProQuest One Academic (retired) ProQuest One Academic UKI Edition ProQuest Central Basic SwePub SwePub Articles SWEPUB Mälardalens högskola |
| DatabaseTitle | CrossRef ABI/INFORM Global (Corporate) ProQuest Business Collection (Alumni Edition) ProQuest One Business Research Library Prep Computer Science Database ProQuest Central Student Technology Collection Technology Research Database Computer and Information Systems Abstracts – Academic ProQuest One Academic Middle East (New) ProQuest Advanced Technologies & Aerospace Collection ProQuest Central Essentials ProQuest Computer Science Collection Computer and Information Systems Abstracts ProQuest Central (Alumni Edition) SciTech Premium Collection ProQuest One Community College Research Library (Alumni Edition) ProQuest Pharma Collection ABI/INFORM Complete ProQuest Central ABI/INFORM Professional Advanced ProQuest One Applied & Life Sciences ABI/INFORM Professional Standard ProQuest Central Korea ProQuest Research Library ProQuest Central (New) Advanced Technologies Database with Aerospace ABI/INFORM Complete (Alumni Edition) Advanced Technologies & Aerospace Collection Business Premium Collection ABI/INFORM Global ProQuest Computing ABI/INFORM Global (Alumni Edition) ProQuest Central Basic ProQuest Computing (Alumni Edition) ProQuest One Academic Eastern Edition ProQuest Technology Collection ProQuest SciTech Collection ProQuest Business Collection Computer and Information Systems Abstracts Professional Advanced Technologies & Aerospace Database ProQuest One Academic UKI Edition ProQuest One Business (Alumni) ProQuest One Academic ProQuest One Academic (New) ProQuest Central (Alumni) Business Premium Collection (Alumni) |
| DatabaseTitleList | ABI/INFORM Global (Corporate) Computer and Information Systems Abstracts |
| Database_xml | – sequence: 1 dbid: BENPR name: ProQuest Central url: https://www.proquest.com/central sourceTypes: Aggregation Database |
| DeliveryMethod | fulltext_linktorsrc |
| Discipline | Computer Science |
| EISSN | 1573-1367 |
| EndPage | 82 |
| ExternalDocumentID | oai_DiVA_org_mdh_31419 4314925861 10_1007_s11219_015_9301_7 |
| Genre | Feature |
| GeographicLocations | United States--US |
| GeographicLocations_xml | – name: United States--US |
| GroupedDBID | -4Z -59 -5G -BR -EM -Y2 -~C .4S .86 .DC .VR 06D 0R~ 0VY 123 1N0 1SB 2.D 203 28- 2J2 2JN 2JY 2KG 2LR 2P1 2VQ 2~H 30V 3V. 4.4 406 408 409 40D 40E 5QI 5VS 67Z 6NX 7WY 8AO 8FE 8FG 8FL 8G5 8TC 95- 95. 95~ 96X AAAVM AABHQ AACDK AAHNG AAIAL AAJBT AAJKR AANZL AAOBN AARHV AARTL AASML AATNV AATVU AAUYE AAWCG AAYIU AAYOK AAYQN AAYTO AAYZH ABAKF ABBBX ABBXA ABDPE ABDZT ABECU ABFTD ABFTV ABHLI ABHQN ABJNI ABJOX ABKCH ABKTR ABMNI ABMQK ABNWP ABQBU ABQSL ABSXP ABTEG ABTHY ABTKH ABTMW ABULA ABUWG ABWNU ABXPI ACAOD ACBXY ACDTI ACGFS ACHSB ACHXU ACKNC ACMDZ ACMLO ACOKC ACOMO ACPIV ACSNA ACZOJ ADHHG ADHIR ADIMF ADINQ ADKNI ADKPE ADMLS ADRFC ADTPH ADURQ ADYFF ADZKW AEBTG AEFIE AEFQL AEGAL AEGNC AEJHL AEJRE AEKMD AEMSY AENEX AEOHA AEPYU AESKC AETLH AEVLU AEXYK AFBBN AFEXP AFGCZ AFKRA AFLOW AFQWF AFWTZ AFZKB AGAYW AGDGC AGGDS AGJBK AGMZJ AGQEE AGQMX AGRTI AGWIL AGWZB AGYKE AHAVH AHBYD AHSBF AHYZX AIAKS AIGIU AIIXL AILAN AITGF AJBLW AJRNO AJZVZ ALMA_UNASSIGNED_HOLDINGS ALWAN AMKLP AMXSW AMYLF AMYQR AOCGG ARAPS ARCSS ARMRJ ASPBG AVWKF AXYYD AYJHY AZFZN AZQEC B-. BA0 BBWZM BDATZ BENPR BEZIV BGLVJ BGNMA BPHCQ BSONS CAG CCPQU COF CS3 CSCUP DDRTE DL5 DNIVK DPUIP DU5 DWQXO EBLON EBS EDO EIOEI EJD ESBYG FEDTE FERAY FFXSO FIGPU FINBP FNLPD FRNLG FRRFC FSGXE FWDCC GGCAI GGRSB GJIRD GNUQQ GNWQR GQ6 GQ7 GQ8 GROUPED_ABI_INFORM_COMPLETE GUQSH GXS H13 HCIFZ HF~ HG5 HG6 HMJXF HQYDN HRMNR HVGLF HZ~ I09 IHE IJ- IKXTQ ITM IWAJR IXC IZIGR IZQ I~X I~Z J-C J0Z JBSCW JCJTX JZLTJ K60 K6V K6~ K7- KDC KOV KOW LAK LLZTM M0C M0N M2O M4Y MA- N2Q NB0 NDZJH NPVJJ NQJWS NU0 O9- O93 O9G O9I O9J OAM OVD P19 P2P P62 P9O PF0 PQBIZ PQBZA PQQKQ PROAC PT4 PT5 Q2X QOK QOS R4E R89 R9I RHV RIG RNI ROL RPX RSV RZC RZE RZK S16 S1Z S26 S27 S28 S3B SAP SCJ SCLPG SCO SDH SDM SHX SISQX SJYHP SNE SNPRN SNX SOHCF SOJ SPISZ SRMVM SSLCW STPWE SZN T13 T16 TEORI TSG TSK TSV TUC TUS U2A UG4 UOJIU UTJUX UZXMN VC2 VFIZW W23 W48 WK8 YLTOR Z45 Z7R Z7S Z7X Z7Z Z81 Z83 Z88 Z8M Z8N Z8R Z8T Z8W Z92 ZMTXR ~A9 ~EX AAPKM AAYXX ABBRH ABDBE ABFSG ABRTQ ACSTC ADHKG AEZWR AFDZB AFFHD AFHIU AFOHR AGQPQ AHPBZ AHWEU AIXLP ATHPR AYFIA CITATION PHGZM PHGZT PQGLB 7SC 7XB 8AL 8FD 8FK JQ2 L.- L.0 L7M L~C L~D MBDVC PKEHL PQEST PQUKI Q9U PUEGO ADTPV AOWAS DF7 |
| ID | FETCH-LOGICAL-c386t-fafe61e5e3563e5375569458c88ec66df5f7a12e4680047bf4254c3c1f2f8d8c3 |
| IEDL.DBID | RSV |
| ISICitedReferencesCount | 20 |
| ISICitedReferencesURI | http://www.webofscience.com/api/gateway?GWVersion=2&SrcApp=Summon&SrcAuth=ProQuest&DestLinkType=CitingArticles&DestApp=WOS_CPL&KeyUT=000394524400003&url=https%3A%2F%2Fcvtisr.summon.serialssolutions.com%2F%23%21%2Fsearch%3Fho%3Df%26include.ft.matches%3Dt%26l%3Dnull%26q%3D |
| ISSN | 0963-9314 1573-1367 |
| IngestDate | Thu Oct 30 11:26:19 EDT 2025 Fri Sep 05 14:10:43 EDT 2025 Tue Nov 04 22:18:51 EST 2025 Sat Nov 29 03:13:12 EST 2025 Tue Nov 18 21:41:56 EST 2025 Fri Feb 21 02:36:37 EST 2025 |
| IsPeerReviewed | true |
| IsScholarly | true |
| Issue | 1 |
| Keywords | Multicore Bugs Debugging process Concurrent Systematic mapping study Fault Parallel Failure |
| Language | English |
| LinkModel | DirectLink |
| MergedId | FETCHMERGED-LOGICAL-c386t-fafe61e5e3563e5375569458c88ec66df5f7a12e4680047bf4254c3c1f2f8d8c3 |
| Notes | SourceType-Scholarly Journals-1 ObjectType-Feature-1 content type line 14 ObjectType-Article-1 ObjectType-Feature-2 content type line 23 |
| PQID | 1869030920 |
| PQPubID | 29106 |
| PageCount | 34 |
| ParticipantIDs | swepub_primary_oai_DiVA_org_mdh_31419 proquest_miscellaneous_1884117800 proquest_journals_1869030920 crossref_citationtrail_10_1007_s11219_015_9301_7 crossref_primary_10_1007_s11219_015_9301_7 springer_journals_10_1007_s11219_015_9301_7 |
| PublicationCentury | 2000 |
| PublicationDate | 2017-03-01 |
| PublicationDateYYYYMMDD | 2017-03-01 |
| PublicationDate_xml | – month: 03 year: 2017 text: 2017-03-01 day: 01 |
| PublicationDecade | 2010 |
| PublicationPlace | New York |
| PublicationPlace_xml | – name: New York – name: Dordrecht |
| PublicationTitle | Software quality journal |
| PublicationTitleAbbrev | Software Qual J |
| PublicationYear | 2017 |
| Publisher | Springer US Springer Nature B.V |
| Publisher_xml | – name: Springer US – name: Springer Nature B.V |
| References | Wang, P., Zhang, X., Hao, P., & Zhang, Y. (2012b). Towards the multithreaded deterministic replay in program debugging. In 2012 8th international conference on information science and digital content technology (ICIDT), Vol. 1, pp. 139–144. IEEE. Lonnberg, J., Ben-Ari, Mordechai, & Malmi, Lauri. (2011). Visualising concurrent programs with dynamic dependence graphs. In Visualizing software for understanding and analysis (VISSOFT), 2011 6th IEEE international workshop on, pp. 1–4. IEEE. Tzoref, R., Ur, S., & Yom-Tov, E., (2007). Instrumenting where it hurts: An automatic concurrent debugging technique. In Proceedings of the 2007 international symposium on software testing and analysis, pp. 27–38. ACM. Uhrig, S. (2011). Tracing static fields of embedded parallel Java applications. In Computer software and applications conference workshops (COMPSACW), 2011 IEEE 35th annual, pp. 516–519. IEEE. EngströmERunesonPSoftware product line testing—A systematic mapping studyInformation Software Technology201153121310.1016/j.infsof.2010.05.011 Wang, Y., Liu, P., Kelly, T., Lafortune, S., Reveliotis, S. A., & Zhang, C. (2012). On atomicity enforcement in concurrent software via discrete event systems theory. In CDC, pp. 7230–7237. Al-Shabibi, A., Gerlach, S., Hersch, R. D., & Schaeli, B. (2007). A debugger for flow graph based parallel applications. In Proceedings of the 2007 ACM workshop on parallel and distributed systems: Testing and debugging, pp. 14–20. ACM. Gottbrath, C. (2006). Eliminating parallel application memory bugs with totalview. In Proceedings of the 2006 ACM/IEEE conference on supercomputing, p. 210. ACM. Negishi, Y., Murata, H., Cong, G., Wen, H.-F., Chung, I. et al. (2012). A static analysis tool using a three-step approach for data races in HPC programs. In Proceedings of the 2012 workshop on parallel and distributed systems: Testing, analysis, and debugging, pp. 11–17. ACM. Kahlon, V. (2012). Automatic lock insertion in concurrent programs. In Formal methods in computer-aided design (FMCAD), 2012, pp. 16–23. IEEE. Brito, M., Felizardo, K. R., Souza, P., & Souza, S. (2010). Concurrent software testing: A systematic review. On testing software and systems: Short papers. Wu, X., Wen, Y., Chen, L., Dong, W., & Wang, J., (2013). Data race detection for interrupt-driven Programs via bounded model checking. In Software security and reliability-companion (SERE-C), 2013 IEEE 7th international conference on, pp. 204–210. IEEE. Kahlon, V., Yang, Y., Sankaranarayanan, S., & Gupta, A. (2007). Fast and accurate static data-race detection for concurrent programs. In Computer aided verification, pp. 226–239. Springer. Kistler, Michael, & Brokenshire, Daniel. (2011). Detecting race conditions in asynchronous DMA operations with full system simulation. In Performance analysis of systems and software (ISPASS), 2011 IEEE international symposium on, pp. 207–215. IEEE. ZhangWDe KruijfMLiAShanLSankaralingamKarthikeyanConAir: Featherweight concurrency bug recovery via single-threaded idempotent executionACM SIGARCH Computer Architecture News2013411113126 Zyulkyarov, F., Harris, T., Unsal, O. S., Cristal, A., & Valero, M. (2010). Debugging programs that use atomic blocks and transactional memory. In ACM sigplan notices, Vol. 45, pp. 57–66. ACM. CoptySUrSToward automatic concurrent debugging via minimal program mutant generation with aspectJElectronic Notes in Theoretical Computer Science2007174915116510.1016/j.entcs.2007.04.001 Gottschlich, J. E., Pokam, G. A., Pereira, C. L., & Wu, Y. (2013). Concurrent predicates: A debugging technique for every parallel programmer. In Proceedings of the 22nd international conference on parallel architectures and compilation techniques, pp. 331–340. IEEE Press. Kim, Y.-J., Kang, M.-H., Ha, O.-K., & Jun, Y.-K. (2007b). Efficient race verification for debugging programs with openMP directives. In Parallel computing technologies, pp. 230–239. Springer. Lu, S., Park, S., Seo, E., & Zhou, Y. (2008). Learning from mistakes: a comprehensive study on real world concurrency bug characteristics. In ACM Sigplan Notices, Vol. 43, pp. 329–339. ACM. TianCNagarajanVGuptaRTallamSAutomated dynamic detection of busywait synchronizationsSoftware: Practice and Experience20093911947972 Machado, N., Romano, P., & Rodrigues, L. (2012). Lightweight cooperative logging for fault replication in concurrent programs. In 2012 42nd annual IEEE/IFIP international conference on dependable systems and networks (DSN), pp. 1–12. IEEE. Shimomura, T., & Ikeda, K. (2013). Waiting blocked-tree type deadlock detection. In Science and information conference (SAI), 2013, pp. 45–50. IEEE. Kasikci, B., Zamfir, C., & Candea, G. (2013). RaceMob: Crowdsourced data race detection. In Proceedings of the twenty-fourth ACM symposium on operating systems principles, pp. 406–422. ACM. Qi, Y., Das, R., Luo, Z. D., & Trotter, M. (2009). Multicoresdk: A practical and efficient data race detector for real-world applications. In Proceedings of the 7th workshop on parallel and distributed systems: Testing, analysis, and debugging, p. 5. ACM. KangM-SHaO-KJunY-KVisualization tool for debugging data races in structured fork-join parallel programsInternational Journal of Software Engineering and Its Applications201484157168 Ma, H., Chen, Q., Wang, L., Liao, C., & Quinlan, D. (2012). An OpenMP analyzer for detecting concurrency errors. In Parallel processing workshops (ICPPW), 2012 41st international conference on, pp. 590–591. IEEE. OßnerCBöhmKGraphs for mining-based defect localization in multithreaded programsInternational Journal of Parallel Programming201341457059310.1007/s10766-012-0237-2 Yuan, D., Mai, H., Xiong, W., Tan, L., Zhou, Y., & Pasupathy, S., (2010). SherLog: Error diagnosis by connecting clues from run-time logs. In ACM SIGARCH computer architecture news, Vol. 38, pp. 143–154. ACM. Lu, L., Ji, W., & Scott, M. L. (2014). Dynamic enforcement of determinism in a parallel scripting language. In Proceedings of the 35th ACM SIGPLAN conference on programming language design and implementation, p. 53. ACM. Park, M.-Y., & Chung, S.-H. (2008). Detection of first races for debugging message-passing programs. In Computer and information technology, 2008. CIT 2008. 8th IEEE international conference on, pp. 261–266. IEEE. Weeratunge, D., Zhang, X., Sumner, W. N., & Jagannathan, S. (2010b). Analyzing concurrency bugs using dual slicing. In Proceedings of the 19th international symposium on Software testing and analysis, pp. 253–264. ACM. DinhMNAbramsonDJinCStatistical assertion: A more powerful method for debugging scientific applicationsJournal of Computational Science20145212613410.1016/j.jocs.2013.12.002 Lucia, B., & Ceze, L. (2009). Finding concurrency bugs with context-aware communication graphs. In Proceedings of the 42nd annual IEEE/ACM international symposium on microarchitecture, pp. 553–563. ACM. Vasudevan, N., Edwards, S. A., & Singh, S., (2008). A deterministic multi-way rendezvous library for Haskell. In IPDPS 2008. IEEE international symposium on parallel and distributed processing, 2008, pp. 1–12. IEEE. Lu, K., Zhou, X., Wang, X., Zhang, W., & Li, G. (2013). RaceFree: An efficient multi-threading model for determinism. In ACM SIGPLAN notices, Vol. 48, pp. 297–298. ACM. TorrellasJCezeLTuckJCascavalCMontesinosPAhnWPrvulovicMThe Bulk Multicore architecture for improved programmabilityCommunications of the ACM20095212586510.1145/1610252.1610271 Martin, J.-P., Hicks, M., Costa, M., Akritidis, P., & Castro, M. (2010). Dynamically checking ownership policies in concurrent C/C++ programs. In ACM Sigplan Notices, Vol. 45, pp. 457–470. ACM. Tchamgoue, G.M., Gan, L., Ha, O.-K., Yang, S.-W., & Jun, Y.-K. (2012). Visualizing concurrency faults in ARINC-653 real-time applications. In Digital avionics systems conference (DASC), 2012 IEEE/AIAA 31st, pp. 9–61. IEEE. WangTShenLMaCA process algebra-based detection model for multithreaded programs in communication systemKSII Transactions on Internet and Information Systems (TIIS)20148396598310.3837/tiis.2014.03.014 Bond, M. D., Kulkarni, M., Cao, M., Zhang, M., Fathi Salmi, M., Biswas, S., Sengupta, A., & Huang, J. (2013). Octet: Capturing and controlling cross-thread dependences efficiently. In ACM SIGPLAN notices, Vol. 48, pp. 693–712. ACM. Abbaspour A. S., Hansson, H., Sundmark, D., & Eldh, S. (2015). Towards classification of concurrency bugs based on Observable properties. In Proceedings of the 1st international workshop on complex faults and failures in large software systems. Italy. http://www.es.mdh.se/pdf_publications/3920.pdf. Huang, J., Meredith, P. O., & Rosu, G. (2014). Maximal sound predictive race detection with control flow abstraction. In Proceedings of the 35th ACM SIGPLAN conference on programming language design and implementation, p. 36. ACM. Jannesari, A., & Tichy, W. F. (2008). On-the-fly race detection in multi-threaded programs. In Proceedings of the 6th workshop on parallel and distributed systems: Testing, analysis, and debugging, p. 6. ACM. Fonseca, P., Li, C., Singhal, V., & Rodrigues, R. (2010). A study of the internal and external effects of concurrency bugs. In 2010 IEEE/IFIP international conference on dependable systems and networks (DSN), pp. 221–230. IEEE. Agarwal, R., & Stoller, S. D. (2006). Run-time detection of potential deadlocks for programs with locks, semaphores, and condition variables. In Proceedings of the 2006 workshop on parallel and distributed systems: Testing and debugging, pp. 51–60. ACM. Hilbrich, T., Protze, J., Schulz, M., de Supinski, B. R., & Mller, M. S. (2012). MPI runtime error detection with MUST: Advances in deadlock detection. In Proceedings of the international conference on high performance computing, networking, storage and analysis, 30. IEEE Computer Society Press. Sack, P., Bliss, B. E., Ma, Z., Petersen, P., & Torrellas, J. (2006). Accurate and efficient filtering for the intel thread checker race detector. In Proceedings of the 1st workshop on Architectural and system support for imp 9301_CR39 9301_CR38 9301_CR32 9301_CR30 9301_CR36 9301_CR35 9301_CR34 T Wang (9301_CR136) 2014; 8 R Wieringa (9301_CR147) 2005; 11 9301_CR157 V Kahlon (9301_CR57) 2013; 15 9301_CR29 Q Gao (9301_CR37) 2011; 39 9301_CR150 9301_CR151 9301_CR152 9301_CR153 9301_CR156 9301_CR20 M Shousha (9301_CR114) 2012; 38 9301_CR25 9301_CR23 9301_CR1 M-S Kang (9301_CR59) 2014; 8 9301_CR146 9301_CR148 9301_CR149 E Engström (9301_CR31) 2011; 53 S Hong (9301_CR45) 2013; 86 9301_CR100 9301_CR101 9301_CR55 9301_CR54 9301_CR58 9301_CR56 9301_CR51 M Mozaffari-Kermani (9301_CR85) 2014; 22 9301_CR50 C-N Wen (9301_CR144) 2012; 61 L Wang (9301_CR133) 2006; 32 9301_CR49 9301_CR44 9301_CR43 9301_CR42 9301_CR41 9301_CR48 D Andersen (9301_CR6) 2007; 24 9301_CR47 9301_CR46 9301_CR40 C Oßner (9301_CR88) 2013; 41 D Rossi (9301_CR103) 2013; 29 MN Dinh (9301_CR27) 2014; 5 F Eichinger (9301_CR28) 2014; 26 9301_CR120 KE Kiefer (9301_CR64) 2013; 43 KI Pun (9301_CR98) 2014; 83 9301_CR121 A Zeller (9301_CR154) 2009 9301_CR77 9301_CR76 9301_CR75 9301_CR74 D Adalid (9301_CR2) 2014; 90 T Kelly (9301_CR62) 2009; 42 9301_CR79 9301_CR78 9301_CR73 C Flanagan (9301_CR33) 2008; 30 9301_CR72 A Jannesari (9301_CR52) 2014; 25 9301_CR71 9301_CR70 S Nanz (9301_CR86) 2013; 55 9301_CR113 9301_CR115 9301_CR116 Y-C Chiu (9301_CR21) 2011; 37 9301_CR117 9301_CR118 W Zhang (9301_CR155) 2013; 41 9301_CR119 9301_CR111 9301_CR112 G Jin (9301_CR53) 2011; 46 9301_CR66 9301_CR65 9301_CR63 S Copty (9301_CR22) 2007; 174 9301_CR68 9301_CR67 H Li (9301_CR69) 2014; 57 V Schuppan (9301_CR110) 2005; 113 9301_CR61 9301_CR60 J Torrellas (9301_CR123) 2009; 52 9301_CR102 9301_CR104 9301_CR105 9301_CR106 9301_CR107 9301_CR109 9301_CR19 9301_CR18 D Weeratunge (9301_CR141) 2010; 45 9301_CR17 9301_CR140 9301_CR16 9301_CR142 9301_CR143 9301_CR145 9301_CR3 9301_CR11 9301_CR99 9301_CR4 9301_CR10 9301_CR5 9301_CR97 9301_CR96 9301_CR7 9301_CR15 9301_CR8 9301_CR14 9301_CR13 9301_CR12 9301_CR91 9301_CR90 9301_CR95 9301_CR94 9301_CR93 9301_CR92 M Mar Gallardo del (9301_CR24) 2006; 10 9301_CR135 9301_CR138 9301_CR139 J Devietti (9301_CR26) 2010; 30 9301_CR130 9301_CR131 9301_CR132 9301_CR134 9301_CR87 9301_CR89 9301_CR80 9301_CR84 C Tian (9301_CR122) 2009; 39 9301_CR83 9301_CR82 9301_CR81 9301_CR124 9301_CR125 9301_CR126 9301_CR127 W Wang (9301_CR137) 2005; 4 9301_CR128 9301_CR129 |
| References_xml | – reference: KahlonVSankaranarayananSGuptaAStatic analysis for concurrent programs with applications to data race detectionInternational Journal on Software Tools for Technology Transfer201315432133610.1007/s10009-013-0274-1 – reference: Buttigieg, V., & Briffa, J. A. (2011). Codebook and marker sequence design for synchronization-correcting codes. In 2011 IEEE international symposium on information theory proceedings (ISIT), pp. 1579–1583. IEEE. – reference: Wang, N., Han, J., & Fang, J. (2012a). A transparent control-flow based approach to record-replay non-deterministic bugs. In 2012 IEEE 7th international conference on networking, architecture and storage (NAS), pp. 189–198. IEEE. – reference: DeviettiJLuciaBCezeLOskinMDMP: Deterministic shared-memory multiprocessingIEEE Micro2010301404910.1109/MM.2010.14 – reference: Gupta, S., Sultan, F., Cadambi, S., Ivancic, F., & Rotteler, M. (2009). Using hardware transactional memory for data race detection. In IEEE international symposium on parallel & distributed processing, 2009. IPDPS 2009. pp. 1–11. IEEE. – reference: Shousha, M., B., Lionel C., & Labiche, Y. (2009). A uml/marte model analysis method for detection of data races in concurrent systems. In Model driven engineering languages and systems, pp. 47–61. Springer. – reference: Huang, R., Halberg, E., & Suh, G. E. (2013). Non-race concurrency bug detection through order-sensitive critical sections. In ACM SIGARCH computer architecture news, Vol. 41, pp. 655–666. ACM. – reference: Park, S. (2013). Debugging non-deadlock concurrency bugs. In Proceedings of the 2013 international symposium on software testing and analysis, pp. 358–361. ACM. – reference: Keele, S. (2007). Guidelines for performing systematic literature reviews in software engineering, Technical report, Technical report, EBSE Technical Report EBSE-2007-01. – reference: Wester, B., Devecsery, D., Chen, P. M., Flinn, J., & Narayanasamy, S. (2013). Parallelizing data race detection. In ACM SIGARCH computer architecture news, Vol. 41, pp. 27–38. ACM. – reference: Sack, P., Bliss, B. E., Ma, Z., Petersen, P., & Torrellas, J. (2006). Accurate and efficient filtering for the intel thread checker race detector. In Proceedings of the 1st workshop on Architectural and system support for improving software dependability, pp. 34–41. ACM. – reference: Lucia, B., & Ceze, L. (2009). Finding concurrency bugs with context-aware communication graphs. In Proceedings of the 42nd annual IEEE/ACM international symposium on microarchitecture, pp. 553–563. ACM. – reference: PunKISteffenMStolzVDeadlock checking by data race detectionJournal of Logical and Algebraic Methods in Programming2014835400426329293510.1016/j.jlamp.2014.07.00306360846 – reference: GaoQZhangWChenZZhengMQinF2ndstrike: Toward manifesting hidden concurrency typestate bugsACM SIGARCH Computer Architecture News201139123925010.1145/1961295.1950394 – reference: Chen, J., & MacDonald, S. (2007). Testing concurrent programs using value schedules. In Proceedings of the twenty-second IEEE/ACM international conference on automated software engineering, pp. 313–322. ACM. – reference: Jyoti, A., & Arora, V. (2014). Debugging and visualization techniques for multithreaded programs: A survey. In Recent advances and innovations in engineering (ICRAIE), 2014, pp. 1–6. IEEE. – reference: Sen, K. (2008). Race directed random testing of concurrent programs. In ACM SIGPLAN notices, Vol. 43, pp. 11–21. ACM. – reference: Wang, Y., Liu, P., Kelly, T., Lafortune, S., Reveliotis, S. A., & Zhang, C. (2012). On atomicity enforcement in concurrent software via discrete event systems theory. In CDC, pp. 7230–7237. – reference: Al-Shabibi, A., Gerlach, S., Hersch, R. D., & Schaeli, B. (2007). A debugger for flow graph based parallel applications. In Proceedings of the 2007 ACM workshop on parallel and distributed systems: Testing and debugging, pp. 14–20. ACM. – reference: Fonseca, P., Li, C., & Rodrigues, R. (2011). Finding complex concurrency bugs in large multi-threaded applications. In Proceedings of the sixth conference on computer systems, pp. 215–228. ACM. – reference: KellyTWangYLafortuneSMahlkeSEliminating concurrency bugs with control engineeringIEEE Computer20094211526010.1109/MC.2009.391 – reference: KieferKEMoserLEReplay debugging of non-deterministic executions in the Kernel-based virtual machineSoftware: Practice and Experience2013431112611281 – reference: WangWFangBReplaying message-passing programs with an efficient logical clockWSEAS Transactions on Computers200547750757 – reference: ZhangWDe KruijfMLiAShanLSankaralingamKarthikeyanConAir: Featherweight concurrency bug recovery via single-threaded idempotent executionACM SIGARCH Computer Architecture News2013411113126 – reference: Wang, P., Zhang, X., Hao, P., & Zhang, Y. (2012b). Towards the multithreaded deterministic replay in program debugging. In 2012 8th international conference on information science and digital content technology (ICIDT), Vol. 1, pp. 139–144. IEEE. – reference: Rister, B. D., Campbell, J., Pillai, P., & Mowry, T. C. (2007). Integrated debugging of large modular robot ensembles. In 2007 IEEE international conference on robotics and automation, pp. 2227–2234. IEEE. – reference: Tzoref, R., Ur, S., & Yom-Tov, E., (2007). Instrumenting where it hurts: An automatic concurrent debugging technique. In Proceedings of the 2007 international symposium on software testing and analysis, pp. 27–38. ACM. – reference: Anvik, J., Hiew, L., & Murphy, G. C. (2006). Who should fix this bug? In Proceedings of the 28th international conference on software engineering, pp. 361–370. ACM. – reference: Chen, H. Y. (2005). Analysis of potential deadlock in Java multithreaded object-oriented programs. In 2005 IEEE international conference on systems, man and cybernetics, Vol. 1, pp. 146–150. IEEE. – reference: Schaeli, B., & Hersch, R. D. (2008). Dynamic testing of flow graph based parallel applications. In Proceedings of the 6th workshop on parallel and distributed systems: Testing, analysis, and debugging, p. 2. ACM. – reference: Lu, K., Zhou, X., Wang, X., Zhang, W., & Li, G. (2013). RaceFree: An efficient multi-threading model for determinism. In ACM SIGPLAN notices, Vol. 48, pp. 297–298. ACM. – reference: Huang, J., & Bond, M. D. (2013). Efficient context sensitivity for dynamic analyses via calling context uptrees and customized memory management. In Proceedings of the 2013 ACM SIGPLAN international conference on object oriented programming systems languages & #38; applications. OOPSLA ’13, pp. 53–72. New York, NY, USA: ACM. ISBN 978-1-4503-2374-1. – reference: Tallam, S., Tian, C., & Gupta, R. (2008). Dynamic slicing of multithreaded programs for race detection. In IEEE International conference on software maintenance, 2008. ICSM 2008, pp. 97–106. IEEE. – reference: Eichinger, F., Pankratius, V., Gro\\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\backslash $$\end{document}s se, P. W. L., & Bhm, K. (2010). Localizing defects in multithreaded programs by mining dynamic call graphs. In Testing practice and research techniques, pp. 56–71. Springer. – reference: Teixeira, B., Loureno, J., Farchi, E., Dias, R., & Sousa, D. (2010). Detection of transactional memory anomalies using static analysis. In Proceedings of the 8th workshop on parallel and distributed systems: Testing, analysis, and debugging, pp. 26–36. ACM. – reference: Chen, Q., & Wang, L. (2009). An integrated framework for checking concurrency-related programming errors. In Computer software and applications conference, 2009. COMPSAC’09. 33rd annual IEEE international, Vol. 1, pp. 676–679. IEEE. – reference: Tchamgoue, G.M., Gan, L., Ha, O.-K., Yang, S.-W., & Jun, Y.-K. (2012). Visualizing concurrency faults in ARINC-653 real-time applications. In Digital avionics systems conference (DASC), 2012 IEEE/AIAA 31st, pp. 9–61. IEEE. – reference: Mozaffari-KermaniMAzarderakhshRLeeC-YBayat-SarmadiSReliable concurrent error detection architectures for extended euclidean-based division over gf(m2). Very large scale integration (VLSI) systemsIEEE Transactions on20142259951003 – reference: EichingerFPankratiusVBohmKData mining for defects in multicore applications: An entropy-based call-graph techniqueConcurrency and Computation: Practice and Experience201426112010.1002/cpe.2918 – reference: WieringaRMaidenNMeadNRollandCRequirements engineering paper classification and evaluation criteria: A proposal and a discussionRequirements Engineering200511110210710.1007/s00766-005-0021-6 – reference: EngströmERunesonPSoftware product line testing—A systematic mapping studyInformation Software Technology201153121310.1016/j.infsof.2010.05.011 – reference: Agarwal, R., & Stoller, S. D. (2006). Run-time detection of potential deadlocks for programs with locks, semaphores, and condition variables. In Proceedings of the 2006 workshop on parallel and distributed systems: Testing and debugging, pp. 51–60. ACM. – reference: FlanaganCFreundSNLifshinMQadeerSTypes for atomicity: Static checking and inference for JavaACM Transactions on Programming Languages and Systems (TOPLAS)20083042010.1145/1377492.1377495 – reference: ZellerAWhy programs fail: A guide to systematic debugging2009AmsterdamElsevier – reference: Yuan, D., Mai, H., Xiong, W., Tan, L., Zhou, Y., & Pasupathy, S., (2010). SherLog: Error diagnosis by connecting clues from run-time logs. In ACM SIGARCH computer architecture news, Vol. 38, pp. 143–154. ACM. – reference: Park, S., Vuduc, R., & Harrold, M. J. (2012). A unified approach for localizing non-deadlock concurrency bugs. In 2012 IEEE Fifth International Conference on software testing, verification and validation (ICST), pp. 51–60. IEEE. – reference: Berger, E. D., Yang, T., Liu, T., & Novark, G. (2009). Grace: Safe multithreaded programming for C/C++. In ACM sigplan notices, Vol. 44, pp. 81–96. ACM. – reference: Wu, X., Wei, J., & Wang, X. (2012). Debug concurrent programs with visualization and inference of event structure. In Software engineering conference (APSEC), 2012 19th Asia-Pacific, Vol. 1, pp. 683–692. IEEE. – reference: Kahlon, V., Yang, Y., Sankaranarayanan, S., & Gupta, A. (2007). Fast and accurate static data-race detection for concurrent programs. In Computer aided verification, pp. 226–239. Springer. – reference: AndersenDImplementing a new application debugging framework for the multi-core ageScientific Computing20072483435 – reference: Gottbrath, C. (2006). Eliminating parallel application memory bugs with totalview. In Proceedings of the 2006 ACM/IEEE conference on supercomputing, p. 210. ACM. – reference: JinGSongLZhangWShanLLiblitBAutomated atomicity-violation fixingACM SIGPLAN Notices201146638940010.1145/1993316.1993544 – reference: Lucia, B., Ceze, L., & Strauss, K. (2010). ColorSafe: Architectural support for debugging and dynamically avoiding multi-variable atomicity violations. In ACM SIGARCH computer architecture news, Vol. 38, pp. 222–233. ACM. – reference: Negishi, Y., Murata, H., Cong, G., Wen, H.-F., Chung, I. et al. (2012). A static analysis tool using a three-step approach for data races in HPC programs. In Proceedings of the 2012 workshop on parallel and distributed systems: Testing, analysis, and debugging, pp. 11–17. ACM. – reference: Lu, L., Ji, W., & Scott, M. L. (2014). Dynamic enforcement of determinism in a parallel scripting language. In Proceedings of the 35th ACM SIGPLAN conference on programming language design and implementation, p. 53. ACM. – reference: Kistler, Michael, & Brokenshire, Daniel. (2011). Detecting race conditions in asynchronous DMA operations with full system simulation. In Performance analysis of systems and software (ISPASS), 2011 IEEE international symposium on, pp. 207–215. IEEE. – reference: WeeratungeDZhangXJagannathanSAnalyzing multicore dumps to facilitate concurrency bug reproductionACM Sigplan Notices201045315516610.1145/1735971.1736039 – reference: Sadowski, C., & Yi, J. (2009). Tiddle: A trace description language for generating concurrent benchmarks to test dynamic analyses. In Proceedings of the seventh international workshop on dynamic analysis, pp. 15–21. ACM. – reference: Gottschlich, J. E., Pokam, G. A., Pereira, C. L., & Wu, Y. (2013). Concurrent predicates: A debugging technique for every parallel programmer. In Proceedings of the 22nd international conference on parallel architectures and compilation techniques, pp. 331–340. IEEE Press. – reference: Raychev, V., Vechev, M., & Sridharan, M. (2013). Effective race detection for event-driven programs. In ACM SIGPLAN notices, Vol. 48, pp. 151–166. ACM. – reference: Serebryany, K., & Iskhodzhanov, T. (2009). ThreadSanitizer: Data race detection in practice. In Proceedings of the workshop on binary instrumentation and applications, pp. 62–71. ACM. – reference: TorrellasJCezeLTuckJCascavalCMontesinosPAhnWPrvulovicMThe Bulk Multicore architecture for improved programmabilityCommunications of the ACM20095212586510.1145/1610252.1610271 – reference: Veeraraghavan, K., Chen, P. M., Flinn, J., & Narayanasamy, S. (2011). Detecting and surviving data races using complementary schedules. In Proceedings of the twenty-third ACM symposium on operating systems principles, pp. 369–384. ACM. – reference: NanzSTorshiziFPedroniMMeyerBDesign of an empirical study for comparing the usability of concurrent programming languagesInformation and Software Technology20135571304131510.1016/j.infsof.2012.08.013 – reference: OßnerCBöhmKGraphs for mining-based defect localization in multithreaded programsInternational Journal of Parallel Programming201341457059310.1007/s10766-012-0237-2 – reference: Park, M.-Y., & Chung, S.-H. (2008). Detection of first races for debugging message-passing programs. In Computer and information technology, 2008. CIT 2008. 8th IEEE international conference on, pp. 261–266. IEEE. – reference: Huang, J., Meredith, P. O., & Rosu, G. (2014). Maximal sound predictive race detection with control flow abstraction. In Proceedings of the 35th ACM SIGPLAN conference on programming language design and implementation, p. 36. ACM. – reference: RossiDOmaaMGarrammoneGMetraCJasAGalivancheRLow cost concurrent error detection strategy for the control logic of high performance microprocessors and its application to the instruction decoderJournal of Electronic Testing201329340141310.1007/s10836-013-5355-2 – reference: Tan, L., Feng, M., & Gupta, R. (2013). Lightweight fault detection in parallelized programs. In 2013 IEEE/ACM International symposium on code generation and optimization (CGO), pp. 1–11. IEEE. – reference: Jannesari, A., & Tichy, W. F. (2008). On-the-fly race detection in multi-threaded programs. In Proceedings of the 6th workshop on parallel and distributed systems: Testing, analysis, and debugging, p. 6. ACM. – reference: TianCNagarajanVGuptaRTallamSAutomated dynamic detection of busywait synchronizationsSoftware: Practice and Experience20093911947972 – reference: WenC-NChouS-HChenC-CChenT-FNUDA: A non-uniform debugging architecture and nonintrusive race detection for many-core systemsComputers, IEEE Transactions on2012612199212293178210.1109/TC.2010.254 – reference: Desouza, J., Kuhn, B., De Supinski, B. R., Samofalov, V., Zheltov, S., & Bratanov, S. (2005). Automated, scalable debugging of MPI programs with Intel Message Checker. In Proceedings of the second international workshop on software engineering for high performance computing system applications, pp. 78–82. ACM. – reference: Trainin, E., Nir-Buchbinder, Y., Tzoref-Brill, R., Zlotnick, A., Ur, S., & Farchi, E. (2009). Forcing small models of conditions on program interleaving for detection of concurrent bugs. In Proceedings of the 7th workshop on parallel and distributed systems: Testing, analysis, and debugging, p. 7. ACM. – reference: ShoushaMBriandLLabicheYA uml/marte model analysis method for uncovering scenarios leading to starvation and deadlocks in concurrent systemsSoftware Engineering, IEEE Transactions on201238235437410.1109/TSE.2010.107 – reference: Bond, M. D., Kulkarni, M., Cao, M., Zhang, M., Fathi Salmi, M., Biswas, S., Sengupta, A., & Huang, J. (2013). Octet: Capturing and controlling cross-thread dependences efficiently. In ACM SIGPLAN notices, Vol. 48, pp. 693–712. ACM. – reference: Arulraj, J., Chang, P.-C., Jin, G., & Lu, S. (2013). Production-run software failure diagnosis via hardware performance counters. In ACM SIGARCH Computer Architecture News, Vol. 41, pp. 101–112. ACM. – reference: Wang, W., Wang, Z., Wu, C., Yew, P.-C., Shen, X., Yuan, X., Li, J., Feng, X., & Guan, Y. (2014). Localization of concurrency bugs using shared memory access pairs. In Proceedings of the 29th ACM/IEEE international conference on Automated software engineering, pp. 611–622. ACM. – reference: Gesbert, L, Hu, Z, Loulergue, F, Matsuzaki, K, & Tesson, J (2010) Systematic development of correct bulk synchronous parallel programs. In 2010 international conference on parallel and distributed computing, applications and technologies (PDCAT), pp. 334–340. IEEE. – reference: Vo, A., & Gopalakrishnan, G. (2010). Scalable verification of MPI programs. In2010 IEEE international symposium on parallel & distributed processing, workshops and Phd forum (IPDPSW), pp. 1–4. IEEE. – reference: DinhMNAbramsonDJinCStatistical assertion: A more powerful method for debugging scientific applicationsJournal of Computational Science20145212613410.1016/j.jocs.2013.12.002 – reference: Ha, O.-K., Kuh, I.-B., Tchamgoue, G. M., & Jun, Y.-K. (2012). On-the-fly detection of data races in OpenMP programs. In Proceedings of the 2012 workshop on parallel and distributed systems: Testing, analysis, and debugging, pp. 1–10. ACM. – reference: Wang, L., & Stoller, S. D. (2006a). Accurate and efficient runtime detection of atomicity errors in concurrent programs. In Proceedings of the eleventh ACM SIGPLAN symposium on Principles and practice of parallel programming, pp. 137–146. ACM. – reference: Wu, X., Wen, Y., Chen, L., Dong, W., & Wang, J., (2013). Data race detection for interrupt-driven Programs via bounded model checking. In Software security and reliability-companion (SERE-C), 2013 IEEE 7th international conference on, pp. 204–210. IEEE. – reference: Hilbrich, T., Protze, J., Schulz, M., de Supinski, B. R., & Mller, M. S. (2012). MPI runtime error detection with MUST: Advances in deadlock detection. In Proceedings of the international conference on high performance computing, networking, storage and analysis, 30. IEEE Computer Society Press. – reference: CoptySUrSToward automatic concurrent debugging via minimal program mutant generation with aspectJElectronic Notes in Theoretical Computer Science2007174915116510.1016/j.entcs.2007.04.001 – reference: Dantas, A., Brasileiro, F., & Cirne, W. (2008). Improving automated testing of multi-threaded software. In 2008 1st international conference on software testing, verification, and validation, pp. 521–524. IEEE. – reference: Uhrig, S. (2011). Tracing static fields of embedded parallel Java applications. In Computer software and applications conference workshops (COMPSACW), 2011 IEEE 35th annual, pp. 516–519. IEEE. – reference: Park, C.-S., & Sen, K. (2008). Randomized active atomicity violation detection in concurrent programs. In Proceedings of the 16th ACM SIGSOFT international symposium on foundations of software engineering, pp. 135–145. ACM. – reference: Wen, C.-N., Chou, S.-H., & Chen, T.-F. (2009). dIP: A non-intrusive debugging IP for dynamic data race detection in many-core. In 2009 10th International symposium on pervasive systems, algorithms, and networks (ISPAN), pp. 86–91. IEEE. – reference: Qi, S., Otsuki, N., Nogueira, L. O., Muzahid, A., & Torrellas, J. (2012). Pacman: Tolerating asymmetric data races with unintrusive hardware. In 2012 IEEE 18th International symposium on high performance computer architecture, pp. 1–12. IEEE. – reference: Kim, Y.-J., Kang, M.-H., Ha, O.-K., & Jun, Y.-K. (2007b). Efficient race verification for debugging programs with openMP directives. In Parallel computing technologies, pp. 230–239. Springer. – reference: Flanagan, C., & Freund, S. N. (2010). Adversarial memory for detecting destructive races. In ACM sigplan notices, Vol. 45, pp. 244–254. ACM. – reference: Hower, D. R., & Hill, M. D. (2008). Rerun: Exploiting episodes for lightweight memory race recording. In ACM SIGARCH computer architecture news, Vol. 36, pp. 265–276. IEEE computer society. – reference: SchuppanVBaurMBiereAJVM independent replay in JavaElectronic Notes in Theoretical Computer Science20051138510410.1016/j.entcs.2004.01.032 – reference: Wen, Y., Zhao, J., Huang, M., & Chen, H. (2011). Towards detecting thread deadlock in java programs with jvm introspection. In Trust, security and privacy in computing and communications (TrustCom), 2011 IEEE 10th International conference on, pp. 1600–1607. IEEE. – reference: Weeratunge, D., Zhang, X., Sumner, W. N., & Jagannathan, S. (2010b). Analyzing concurrency bugs using dual slicing. In Proceedings of the 19th international symposium on Software testing and analysis, pp. 253–264. ACM. – reference: Wang, J.-Y., Shue, Y.-S., & Bagchi, S. (2007). Pesticide: Using SMT to improve performance of pointer-bug detection. In International conference on computer design, 2006. ICCD 2006, pp. 514–521. IEEE. – reference: KangM-SHaO-KJunY-KVisualization tool for debugging data races in structured fork-join parallel programsInternational Journal of Software Engineering and Its Applications201484157168 – reference: Zaineb, G., & Manarvi, I. A. (2011). Identification and analysis of causes for software bug rejection with their impact over testing efficiency. International journal of software engineering & applications (IJSEA) 2 (4). http://airccse.org/journal/ijsea/papers/1011ijsea07.pdf. – reference: Joshi, P., & Sen, K. (2008). Predictive typestate checking of multithreaded java programs. In Proceedings of the 2008 23rd IEEE/ACM international conference on automated software engineering, pp. 288–296. IEEE computer society. – reference: ChiuY-CShiehC-KHuangT-CLiangT-YChuK-CData race avoidance and replay scheme for developing and debugging parallel programs on distributed shared memory systemsParallel Computing2011371112510.1016/j.parco.2010.09.0021211.68068 – reference: Altekar, G., & Stoica, I. (2009). ODR: Output-deterministic replay for multicore debugging. In Proceedings of the ACM SIGOPS 22nd symposium on operating systems principles, pp. 193–206. ACM. – reference: Kasikci, B., Zamfir, C., & Candea, G. (2013). RaceMob: Crowdsourced data race detection. In Proceedings of the twenty-fourth ACM symposium on operating systems principles, pp. 406–422. ACM. – reference: Moiseev, M., Glukhikh, M., Zakharov, A., & Richter, H. (2013). A static analysis approach to data race detection in systemic designs. In 2013 IEEE 16th international symposium on design and diagnostics of electronic circuits & systems (DDECS), pp. 54–59. IEEE. – reference: Qi, Y., Das, R., Luo, Z. D., & Trotter, M. (2009). Multicoresdk: A practical and efficient data race detector for real-world applications. In Proceedings of the 7th workshop on parallel and distributed systems: Testing, analysis, and debugging, p. 5. ACM. – reference: Fonseca, P., Li, C., Singhal, V., & Rodrigues, R. (2010). A study of the internal and external effects of concurrency bugs. In 2010 IEEE/IFIP international conference on dependable systems and networks (DSN), pp. 221–230. IEEE. – reference: AdalidDSalmernAdel Mar GallardoMMerinoPUsing SPIN for automated debugging of infinite executions of Java programsJournal of Systems and Software201490617510.1016/j.jss.2013.10.056 – reference: Watson, G. R., Rasmussen, C. E., Tibbitts, B. R. (2009). An integrated approach to improving the parallel application development process. In IEEE International Symposium on parallel & distributed processing, 2009. IPDPS 2009, pp. 1–8. IEEE. – reference: Park, C.-S., & Sen, K. (2012). Concurrent breakpoints. In ACM SIGPLAN notices, Vol. 47, pp. 331–332. ACM. – reference: Elmas, T., Sezgin, A., Tasiran, S., & Qadeer, S. (2009). An annotation assistant for interactive debugging of programs with common synchronization idioms. In Proceedings of the 7th workshop on parallel and distributed systems: Testing, analysis, and debugging, p. 10. ACM. – reference: Viennot, N., Nair, S., & Nieh, J. (2013). Transparent mutable replay for multicore debugging and patch validation. In ACM SIGARCH computer architecture news, Vol. 41, pp. 127–138. ACM. – reference: JannesariATichyWFLibrary-independent data race detectionParallel and Distributed Systems, IEEE Transactions on201425102606261610.1109/TPDS.2013.209 – reference: Montesinos, P., Ceze, L., & Torrellas, J. (2008). Delorean: Recording and deterministically replaying shared-memory multiprocessor execution ef? ciently. In 35th International symposium on computer architecture, 2008. ISCA’08, pp. 289–300. IEEE. – reference: Park, M.-Y., Kim, S. Y., & Park, H.-R. (2007). Visualization of affect-relations of message races for debugging MPI programs. In IEEE international conference on granular computing, 2007. GRC 2007. pp. 745–745. IEEE. – reference: HongSKimMEffective pattern-driven concurrency bug detection for operating systemsJournal of Systems and Software201386237738810.1016/j.jss.2012.08.063 – reference: Francesca, G., Santone, A., Vaglini, G., & Villani, M. L. (2011). Ant colony optimization for deadlock detection in concurrent systems. In Computer software and applications conference (COMPSAC), 2011 IEEE 35th Annual, pp. 108–117. IEEE. – reference: Jalali, S., & Wohlin, C. (2012). Systematic literature studies: Database searches versus backward snowballing. In 2012 ACM-IEEE International symposium on empirical software engineering and measurement (ESEM), pp. 29–38, doi:10.1145/2372251.2372257. – reference: Kim, Y.-J., Lim, J.-S., & Jun, Y.-K. (2007a). Scalable thread visualization for debugging data races in OpenMP programs. In Advances in grid and pervasive computing, pp. 310–321. Springer. – reference: Said, M., Wang, C., Yang, Z., & Sakallah, K. (2011). Generating data race witnesses by an SMT-based analysis. In NASA formal methods, pp. 313–327. Springer. – reference: Chen, S.-Y., Neng, C., Yang, G.-H., Jone, W.-B., & Chen, T.-F. (2012). IMITATOR: A deterministic multicore replay system with refining techniques. In 2012 international symposium on VLSI design, automation, and test (VLSI-DAT), pp. 1–4. IEEE. – reference: Maiya, P., Kanade, A., & Majumdar, R. (2014). Race detection for Android applications. In Proceedings of the 35th ACM SIGPLAN conference on programming language design and implementation, p. 34. ACM. – reference: Ma, H., Chen, Q., Wang, L., Liao, C., & Quinlan, D. (2012). An OpenMP analyzer for detecting concurrency errors. In Parallel processing workshops (ICPPW), 2012 41st international conference on, pp. 590–591. IEEE. – reference: Yoshiura, N., & Wei, W. (2014). Static data race detection for Java programs with dynamic class loading. In Internet and distributed computing systems, pp. 161–173. Springer. – reference: Lonnberg, J., Ben-Ari, Mordechai, & Malmi, Lauri. (2011). Visualising concurrent programs with dynamic dependence graphs. In Visualizing software for understanding and analysis (VISSOFT), 2011 6th IEEE international workshop on, pp. 1–4. IEEE. – reference: Machado, N., Romano, P., & Rodrigues, L. (2012). Lightweight cooperative logging for fault replication in concurrent programs. In 2012 42nd annual IEEE/IFIP international conference on dependable systems and networks (DSN), pp. 1–12. IEEE. – reference: Kahlon, V. (2012). Automatic lock insertion in concurrent programs. In Formal methods in computer-aided design (FMCAD), 2012, pp. 16–23. IEEE. – reference: Vasudevan, N., Edwards, S. A., & Singh, S., (2008). A deterministic multi-way rendezvous library for Haskell. In IPDPS 2008. IEEE international symposium on parallel and distributed processing, 2008, pp. 1–12. IEEE. – reference: Petersen, K., Feldt, R., Mujtaba, S., & Mattsson, M. (2008). Systematic mapping studies in software engineering. In 12th International conference on evaluation and assessment in software engineering, Vol. 17. – reference: Chen, F., Serbanuta, T.-F., & Rosu, G. (2008). jPredictor. In ACM/IEEE 30th international conference on software engineering, 2008. ICSE’08, pp. 221–230. IEEE. – reference: Yu, J., Ci, Y., Zhou, P., Wu, Y., & Zhao, C. (2012). Deterministic replay of multithread applications using virtual machine. In Advanced information networking and applications workshops (WAINA), 2012 26th International conference on, pp. 429–434. IEEE. – reference: Zhou, P., Teodorescu, R., & Zhou, Y. (2007). HARD: Hardware-assisted lockset-based race detection. In IEEE 13th International symposium on high performance computer architecture, 2007. HPCA 2007, pp. 121–132. IEEE. – reference: Liu, P., & Zhang, C. (2012). Axis: Automatically fixing atomicity violations through solving control constraints. In Proceedings of the 34th international conference on software engineering, pp. 299–309. IEEE Press. – reference: Makela, J.-M., Leppanen, V., & Forsell, M. (2013). Towards a parallel debugging framework for the massively multi-threaded, step-synchronous REPLICA architecture. In Proceedings of the 14th international conference on computer systems and technologies, pp. 153–160. ACM. – reference: Park, H.-D., & Jun, Y.-K. (2012). Detecting first races in shared-memory parallel programs with random synchronization. In Computer applications for graphics, grid computing, and industrial environment, pp. 165–169. Springer. – reference: Lu, S., Jiang, W., & Zhou, Y. (2007). A study of interleaving coverage criteria. In The 6th joint meeting on European software engineering conference and the ACM SIGSOFT symposium on the foundations of software engineering: companion papers, pp. 533–536. ACM. – reference: Martin, J.-P., Hicks, M., Costa, M., Akritidis, P., & Castro, M. (2010). Dynamically checking ownership policies in concurrent C/C++ programs. In ACM Sigplan Notices, Vol. 45, pp. 457–470. ACM. – reference: Tchamgoue, G. M., Kuh, I.-B., Ha, O.-K., Kim, K.-H., & Jun, Y.-K. (2010). A race healing framework in simulated ARINC-653. In Communication and networking, pp. 238–246. Springer. – reference: Song, Y. W., & Lee, Y.-H. (2014). Efficient data race detection for C/C++ programs using dynamic granularity. In Parallel and distributed processing symposium, 2014 IEEE 28th international, pp. 679–688. IEEE. – reference: Zyulkyarov, F., Harris, T., Unsal, O. S., Cristal, A., & Valero, M. (2010). Debugging programs that use atomic blocks and transactional memory. In ACM sigplan notices, Vol. 45, pp. 57–66. ACM. – reference: Brito, M., Felizardo, K. R., Souza, P., & Souza, S. (2010). Concurrent software testing: A systematic review. On testing software and systems: Short papers. – reference: del Mar GallardoMMartnezJMerinoPPimentelEOn the evolution of reliability methods for critical softwareJournal of Integrated Design and Process Science20061045567 – reference: Chen, Y., & Chen, H. (2013). Scalable deterministic replay in a parallel full-system emulator. In ACM SIGPLAN notices, Vol. 48, pp. 207–218. ACM. – reference: Ball, T., Burckhardt, S., de Halleux, J., Musuvathi, M., & Qadeer, S. (2009). Deconstructing concurrency heisenbugs. In 31st international conference on software engineering-companion volume, 2009. ICSE-Companion 2009, pp. 403–404. IEEE. – reference: WangTShenLMaCA process algebra-based detection model for multithreaded programs in communication systemKSII Transactions on Internet and Information Systems (TIIS)20148396598310.3837/tiis.2014.03.014 – reference: Khoshavi, N., Zarandi, H.R., & Maghsoudloo, M. (2012). Two control-flow error recovery methods for multithreaded programs running on multi-core processors. In Microelectronics (MIEL), 2012 28th international conference on, pp. 371–374. IEEE. – reference: Kim, B.-C., & Jun, Y.-K. (2010). Program visualization for debugging deadlocks in multithreaded programs. In Advances in software engineering, pp. 228–236. Springer. – reference: Shimomura, T., & Ikeda, K. (2013). Waiting blocked-tree type deadlock detection. In Science and information conference (SAI), 2013, pp. 45–50. IEEE. – reference: Godefroid, P. (1997). Model checking for programming languages using verisoft. In Proceedings of the 24th acm sigplan-sigact symposium on principles of programming languages (popl’97). New York, NY, USA: ACM. – reference: Schneider, J. (2014). Tracking down root causes of defects in simulink models. In Proceedings of the 29th ACM/IEEE international conference on Automated software engineering. ACM. – reference: Abbaspour A. S., Hansson, H., Sundmark, D., & Eldh, S. (2015). Towards classification of concurrency bugs based on Observable properties. In Proceedings of the 1st international workshop on complex faults and failures in large software systems. Italy. http://www.es.mdh.se/pdf_publications/3920.pdf. – reference: LiHLuoJLiWA formal semantics for debugging synchronous message passing-based concurrent programsScience China Information Sciences201457121181314.68101 – reference: Prvulovic, M. (2006). CORD: Cost-effective (and nearly overhead-free) order-recording and data race detection. In The twelfth international symposium on high-performance computer architecture, 2006, pp. 232–243. IEEE. – reference: Lu, S., Park, S., Seo, E., & Zhou, Y. (2008). Learning from mistakes: a comprehensive study on real world concurrency bug characteristics. In ACM Sigplan Notices, Vol. 43, pp. 329–339. ACM. – reference: WangLStollerSDRuntime analysis of atomicity for multithreaded programsSoftware Engineering, IEEE Transactions on20063229311010.1109/TSE.2006.1599419 – ident: 9301_CR48 doi: 10.1145/2509136.2509510 – ident: 9301_CR157 doi: 10.1145/1837853.1693463 – ident: 9301_CR94 doi: 10.1145/2483760.2492395 – ident: 9301_CR92 doi: 10.1109/CIT.2008.4594684 – ident: 9301_CR138 doi: 10.1145/2642937.2642972 – ident: 9301_CR148 doi: 10.1109/APSEC.2012.134 – ident: 9301_CR16 doi: 10.1109/ICSMC.2005.1571136 – volume: 86 start-page: 377 issue: 2 year: 2013 ident: 9301_CR45 publication-title: Journal of Systems and Software doi: 10.1016/j.jss.2012.08.063 – ident: 9301_CR49 doi: 10.1145/2508148.2485978 – ident: 9301_CR129 doi: 10.1145/2451116.2451130 – volume: 41 start-page: 113 issue: 1 year: 2013 ident: 9301_CR155 publication-title: ACM SIGARCH Computer Architecture News doi: 10.1145/2490301.2451129 – volume: 43 start-page: 1261 issue: 11 year: 2013 ident: 9301_CR64 publication-title: Software: Practice and Experience – volume: 5 start-page: 126 issue: 2 year: 2014 ident: 9301_CR27 publication-title: Journal of Computational Science doi: 10.1016/j.jocs.2013.12.002 – ident: 9301_CR44 doi: 10.1109/SC.2012.79 – ident: 9301_CR134 doi: 10.1109/NAS.2012.28 – ident: 9301_CR41 – ident: 9301_CR72 doi: 10.1145/2517327.2442553 – ident: 9301_CR73 doi: 10.1145/2666356.2594300 – ident: 9301_CR75 doi: 10.1145/1353536.1346323 – ident: 9301_CR91 doi: 10.1007/978-3-642-35600-1_24 – ident: 9301_CR68 doi: 10.1109/ISPASS.2011.5762737 – ident: 9301_CR15 doi: 10.1145/1368088.1368119 – volume: 57 start-page: 1 issue: 12 year: 2014 ident: 9301_CR69 publication-title: Science China Information Sciences – ident: 9301_CR125 doi: 10.1145/1273463.1273469 – volume: 39 start-page: 239 issue: 1 year: 2011 ident: 9301_CR37 publication-title: ACM SIGARCH Computer Architecture News doi: 10.1145/1961295.1950394 – ident: 9301_CR132 doi: 10.1145/1122971.1122993 – ident: 9301_CR36 doi: 10.1109/COMPSAC.2011.22 – ident: 9301_CR29 doi: 10.1007/978-3-642-15585-7_7 – ident: 9301_CR58 doi: 10.1007/978-3-540-73368-3_26 – ident: 9301_CR54 doi: 10.1109/ASE.2008.39 – ident: 9301_CR70 doi: 10.1109/ICSE.2012.6227184 – ident: 9301_CR5 doi: 10.1145/1629575.1629594 – ident: 9301_CR7 doi: 10.1145/1134285.1134336 – ident: 9301_CR46 doi: 10.1145/1394608.1382144 – ident: 9301_CR93 doi: 10.1109/GrC.2007.120 – ident: 9301_CR150 doi: 10.1007/978-3-319-11692-1_14 – volume: 46 start-page: 389 issue: 6 year: 2011 ident: 9301_CR53 publication-title: ACM SIGPLAN Notices doi: 10.1145/1993316.1993544 – volume: 4 start-page: 750 issue: 7 year: 2005 ident: 9301_CR137 publication-title: WSEAS Transactions on Computers – ident: 9301_CR89 doi: 10.1145/1453101.1453121 – ident: 9301_CR18 doi: 10.1109/COMPSAC.2009.105 – volume: 42 start-page: 52 issue: 11 year: 2009 ident: 9301_CR62 publication-title: IEEE Computer doi: 10.1109/MC.2009.391 – volume: 26 start-page: 1 issue: 1 year: 2014 ident: 9301_CR28 publication-title: Concurrency and Computation: Practice and Experience doi: 10.1002/cpe.2918 – ident: 9301_CR142 doi: 10.1145/1831708.1831740 – volume: 8 start-page: 157 issue: 4 year: 2014 ident: 9301_CR59 publication-title: International Journal of Software Engineering and Its Applications – ident: 9301_CR130 doi: 10.1109/IPDPSW.2010.5470683 – ident: 9301_CR115 doi: 10.1007/978-3-642-04425-0_5 – ident: 9301_CR104 doi: 10.1145/1181309.1181315 – ident: 9301_CR151 doi: 10.1109/WAINA.2012.124 – volume: 37 start-page: 11 issue: 1 year: 2011 ident: 9301_CR21 publication-title: Parallel Computing doi: 10.1016/j.parco.2010.09.002 – ident: 9301_CR17 doi: 10.1145/1321631.1321678 – volume: 53 start-page: 2 issue: 1 year: 2011 ident: 9301_CR31 publication-title: Information Software Technology doi: 10.1016/j.infsof.2010.05.011 – ident: 9301_CR42 doi: 10.1109/IPDPS.2009.5161006 – volume: 10 start-page: 55 issue: 4 year: 2006 ident: 9301_CR24 publication-title: Journal of Integrated Design and Process Science – ident: 9301_CR79 doi: 10.1109/DSN.2012.6263953 – ident: 9301_CR12 doi: 10.1145/2544173.2509519 – ident: 9301_CR121 doi: 10.1145/1866210.1866213 – ident: 9301_CR34 doi: 10.1145/1966445.1966465 – ident: 9301_CR23 doi: 10.1109/ICST.2008.38 – volume: 32 start-page: 93 issue: 2 year: 2006 ident: 9301_CR133 publication-title: Software Engineering, IEEE Transactions on doi: 10.1109/TSE.2006.1599419 – volume: 8 start-page: 965 issue: 3 year: 2014 ident: 9301_CR136 publication-title: KSII Transactions on Internet and Information Systems (TIIS) doi: 10.3837/tiis.2014.03.014 – volume: 41 start-page: 570 issue: 4 year: 2013 ident: 9301_CR88 publication-title: International Journal of Parallel Programming doi: 10.1007/s10766-012-0237-2 – ident: 9301_CR117 doi: 10.1109/ICSM.2008.4658058 – ident: 9301_CR87 doi: 10.1145/2338967.2336809 – ident: 9301_CR60 doi: 10.1145/2517349.2522736 – ident: 9301_CR95 doi: 10.1109/ICST.2012.85 – ident: 9301_CR80 doi: 10.1145/2666356.2594311 – ident: 9301_CR83 doi: 10.1109/DDECS.2013.6549788 – ident: 9301_CR47 doi: 10.1145/2666356.2594315 – ident: 9301_CR71 doi: 10.1109/VISSOF.2011.6069456 – volume: 29 start-page: 401 issue: 3 year: 2013 ident: 9301_CR103 publication-title: Journal of Electronic Testing doi: 10.1007/s10836-013-5355-2 – ident: 9301_CR61 – ident: 9301_CR13 – ident: 9301_CR105 doi: 10.1145/2134243.2134248 – ident: 9301_CR40 doi: 10.1145/1188455.1188674 – ident: 9301_CR102 doi: 10.1109/ROBOT.2007.363651 – ident: 9301_CR139 doi: 10.1109/CDC.2012.6426112 – ident: 9301_CR81 doi: 10.1145/2516775.2516818 – ident: 9301_CR118 – volume: 52 start-page: 58 issue: 12 year: 2009 ident: 9301_CR123 publication-title: Communications of the ACM doi: 10.1145/1610252.1610271 – ident: 9301_CR14 doi: 10.1109/ISIT.2011.6033810 – volume: 174 start-page: 151 issue: 9 year: 2007 ident: 9301_CR22 publication-title: Electronic Notes in Theoretical Computer Science doi: 10.1016/j.entcs.2007.04.001 – ident: 9301_CR82 doi: 10.1145/1707801.1706351 – volume: 30 start-page: 40 issue: 1 year: 2010 ident: 9301_CR26 publication-title: IEEE Micro doi: 10.1109/MM.2010.14 – ident: 9301_CR84 doi: 10.1109/ISCA.2008.36 – ident: 9301_CR135 – ident: 9301_CR76 doi: 10.1145/1669112.1669181 – volume: 45 start-page: 155 issue: 3 year: 2010 ident: 9301_CR141 publication-title: ACM Sigplan Notices doi: 10.1145/1735971.1736039 – ident: 9301_CR35 doi: 10.1109/DSN.2010.5544315 – ident: 9301_CR107 – ident: 9301_CR99 doi: 10.1109/HPCA.2012.6169039 – ident: 9301_CR25 doi: 10.1145/1145319.1145342 – volume-title: Why programs fail: A guide to systematic debugging year: 2009 ident: 9301_CR154 – ident: 9301_CR50 doi: 10.1145/2372251.2372257 – ident: 9301_CR38 doi: 10.1109/PDCAT.2010.86 – ident: 9301_CR67 doi: 10.1007/978-3-540-73940-1_24 – ident: 9301_CR113 – ident: 9301_CR19 – ident: 9301_CR77 doi: 10.1145/1816038.1815988 – ident: 9301_CR4 doi: 10.1145/1273647.1273651 – volume: 25 start-page: 2606 issue: 10 year: 2014 ident: 9301_CR52 publication-title: Parallel and Distributed Systems, IEEE Transactions on doi: 10.1109/TPDS.2013.209 – volume: 11 start-page: 102 issue: 1 year: 2005 ident: 9301_CR147 publication-title: Requirements Engineering doi: 10.1007/s00766-005-0021-6 – ident: 9301_CR127 doi: 10.1109/IPDPS.2008.4536312 – volume: 38 start-page: 354 issue: 2 year: 2012 ident: 9301_CR114 publication-title: Software Engineering, IEEE Transactions on doi: 10.1109/TSE.2010.107 – ident: 9301_CR106 doi: 10.1007/978-3-642-20398-5_23 – volume: 30 start-page: 20 issue: 4 year: 2008 ident: 9301_CR33 publication-title: ACM Transactions on Programming Languages and Systems (TOPLAS) doi: 10.1145/1377492.1377495 – ident: 9301_CR143 doi: 10.1109/I-SPAN.2009.123 – ident: 9301_CR101 doi: 10.1145/2544173.2509538 – ident: 9301_CR30 doi: 10.1145/1639622.1639632 – volume: 15 start-page: 321 issue: 4 year: 2013 ident: 9301_CR57 publication-title: International Journal on Software Tools for Technology Transfer doi: 10.1007/s10009-013-0274-1 – volume: 39 start-page: 947 issue: 11 year: 2009 ident: 9301_CR122 publication-title: Software: Practice and Experience – ident: 9301_CR65 doi: 10.1007/978-3-642-17578-7_23 – volume: 61 start-page: 199 issue: 2 year: 2012 ident: 9301_CR144 publication-title: Computers, IEEE Transactions on doi: 10.1109/TC.2010.254 – ident: 9301_CR153 – ident: 9301_CR56 – ident: 9301_CR55 doi: 10.1109/ICRAIE.2014.6909202 – volume: 113 start-page: 85 year: 2005 ident: 9301_CR110 publication-title: Electronic Notes in Theoretical Computer Science doi: 10.1016/j.entcs.2004.01.032 – ident: 9301_CR145 doi: 10.1109/TrustCom.2011.222 – ident: 9301_CR66 doi: 10.1007/978-3-540-72360-8_27 – ident: 9301_CR1 – ident: 9301_CR43 doi: 10.1145/2338967.2336808 – ident: 9301_CR152 doi: 10.1145/1735970.1736038 – ident: 9301_CR32 doi: 10.1145/1809028.1806625 – ident: 9301_CR116 doi: 10.1109/IPDPS.2014.76 – ident: 9301_CR140 doi: 10.1109/IPDPS.2009.5160941 – ident: 9301_CR126 doi: 10.1109/COMPSACW.2011.94 – volume: 90 start-page: 61 year: 2014 ident: 9301_CR2 publication-title: Journal of Systems and Software doi: 10.1016/j.jss.2013.10.056 – ident: 9301_CR124 doi: 10.1145/1639622.1639629 – ident: 9301_CR111 doi: 10.1145/1379022.1375584 – ident: 9301_CR146 doi: 10.1145/2451116.2451120 – ident: 9301_CR112 doi: 10.1145/1791194.1791203 – ident: 9301_CR10 doi: 10.1109/ICSE-COMPANION.2009.5071033 – ident: 9301_CR149 doi: 10.1109/SERE-C.2013.33 – ident: 9301_CR119 – volume: 22 start-page: 995 issue: 5 year: 2014 ident: 9301_CR85 publication-title: IEEE Transactions on – ident: 9301_CR20 doi: 10.1145/2517327.2442537 – ident: 9301_CR74 doi: 10.1145/1287624.1287703 – ident: 9301_CR100 doi: 10.1145/1639622.1639627 – ident: 9301_CR3 doi: 10.1145/1147403.1147413 – ident: 9301_CR39 doi: 10.1145/263699.263717 – ident: 9301_CR90 doi: 10.1145/2370036.2145880 – ident: 9301_CR131 – ident: 9301_CR156 doi: 10.1109/HPCA.2007.346191 – ident: 9301_CR51 – volume: 55 start-page: 1304 issue: 7 year: 2013 ident: 9301_CR86 publication-title: Information and Software Technology doi: 10.1016/j.infsof.2012.08.013 – ident: 9301_CR120 doi: 10.1007/978-3-642-17604-3_28 – ident: 9301_CR8 doi: 10.1145/2451116.2451128 – ident: 9301_CR63 doi: 10.1109/MIEL.2012.6222877 – ident: 9301_CR128 doi: 10.1145/2043556.2043590 – volume: 83 start-page: 400 issue: 5 year: 2014 ident: 9301_CR98 publication-title: Journal of Logical and Algebraic Methods in Programming doi: 10.1016/j.jlamp.2014.07.003 – ident: 9301_CR109 doi: 10.1145/2642937.2642943 – ident: 9301_CR11 doi: 10.1145/1639949.1640096 – ident: 9301_CR97 doi: 10.1109/HPCA.2006.1598132 – volume: 24 start-page: 34 issue: 8 year: 2007 ident: 9301_CR6 publication-title: Scientific Computing – ident: 9301_CR78 doi: 10.1109/ICPPW.2012.83 – ident: 9301_CR96 doi: 10.14236/ewic/EASE2008.8 |
| SSID | ssj0010074 |
| Score | 2.1904101 |
| Snippet | Debugging—the process of identifying, localizing and fixing bugs—is a key activity in software development . Due to issues such as non-determinism and... Debugging--the process of identifying, localizing and fixing bugs--is a key activity in software development . Due to issues such as non-determinism and... Debugging-the process of identifying, localizing and fixing bugs-is a key activity in software development . Due to issues such as non-determinism and... Debugging – the process of identifying, localizing and fixing bugs – is a key activity in software development. Due to issues such as non-determinism and... |
| SourceID | swepub proquest crossref springer |
| SourceType | Open Access Repository Aggregation Database Enrichment Source Index Database Publisher |
| StartPage | 49 |
| SubjectTerms | Compilers Computer programs Computer Science Concurrency Conferences Data Structures and Information Theory Debugging Documents Interpreters Mapping Operating Systems Programming Languages Research methodology Software Software engineering Software Engineering/Programming and Operating Systems Software quality Studies Taxonomy Trends |
| SummonAdditionalLinks | – databaseName: Computer Science Database dbid: K7- link: http://cvtisr.summon.serialssolutions.com/2.0.0/link/0/eLvHCXMwpV1Lb9QwELagcOBCeYqFgowEF1BEbMeO00tVtVRISBUHQOVk2WNnW6lNyma3_ft4vE4WkOiFY2QnsTXfPOyxvyHkjeNaOR_1mztdFhVzonAQ4qN3DTDg0lmbik3Ux8f65KT5kjfchnyscrSJyVD7HnCP_EMqnSTKhpd7lz8LrBqF2dVcQuM2ucM4Z4jzz3UxZRHQPyauPSWKRrBqzGqmq3OM4_UdJmNLXFHXf_qlTbA55Uf_4hJN_udo-39H_oDcz5En3V9D5SG5FbpHZHus6kCzkj8mhpX0R8T_QPuWZi6gU9p31Ae3wv3pOY1raFjzOlHbeZoOJSIdJh2iUb-2i7BLLd1wRNMLiywQc5q4bJ-Qb0cfvx58KnIZhgKEVsuitW1QLMggpBJBilpK1VRSg9YBlPKtbGvLeKiURu5J10YzUIEA1vJWew3iKdnq-i48I1QpKb13InrmGEoGsEzbgBeqbOnAAcxIOQrBQOYox1IZ52bDroxyM1FuBuVm6hl5N71yuSbouKnzzigik3V1MBv5zMjrqTlqGaZObBf6FfbRFWN1nOCMvB8R8dsn_v3Dt2vQTGNDOu_Ds-_7pl_MzYU_NRGXrHl-88BekHscw4l09m2HbC0Xq_CS3IWr5dmweJVA_wvUaAg7 priority: 102 providerName: ProQuest |
| Title | 10 Years of research on debugging concurrent and multicore software: a systematic mapping study |
| URI | https://link.springer.com/article/10.1007/s11219-015-9301-7 https://www.proquest.com/docview/1869030920 https://www.proquest.com/docview/1884117800 https://urn.kb.se/resolve?urn=urn:nbn:se:mdh:diva-31419 |
| Volume | 25 |
| WOSCitedRecordID | wos000394524400003&url=https%3A%2F%2Fcvtisr.summon.serialssolutions.com%2F%23%21%2Fsearch%3Fho%3Df%26include.ft.matches%3Dt%26l%3Dnull%26q%3D |
| hasFullText | 1 |
| inHoldings | 1 |
| isFullTextHit | |
| isPrint | |
| journalDatabaseRights | – providerCode: PRVPQU databaseName: AAdvanced Technologies & Aerospace Database (subscription) customDbUrl: eissn: 1573-1367 dateEnd: 20171231 omitProxy: false ssIdentifier: ssj0010074 issn: 0963-9314 databaseCode: P5Z dateStart: 19970101 isFulltext: true titleUrlDefault: https://search.proquest.com/hightechjournals providerName: ProQuest – providerCode: PRVPQU databaseName: ABI/INFORM Collection customDbUrl: eissn: 1573-1367 dateEnd: 20171231 omitProxy: false ssIdentifier: ssj0010074 issn: 0963-9314 databaseCode: 7WY dateStart: 19970101 isFulltext: true titleUrlDefault: https://www.proquest.com/abicomplete providerName: ProQuest – providerCode: PRVPQU databaseName: ABI/INFORM Global (ProQuest) customDbUrl: eissn: 1573-1367 dateEnd: 20171231 omitProxy: false ssIdentifier: ssj0010074 issn: 0963-9314 databaseCode: M0C dateStart: 19970101 isFulltext: true titleUrlDefault: https://search.proquest.com/abiglobal providerName: ProQuest – providerCode: PRVPQU databaseName: Computer Science Database customDbUrl: eissn: 1573-1367 dateEnd: 20171231 omitProxy: false ssIdentifier: ssj0010074 issn: 0963-9314 databaseCode: K7- dateStart: 19970101 isFulltext: true titleUrlDefault: http://search.proquest.com/compscijour providerName: ProQuest – providerCode: PRVPQU databaseName: ProQuest Central customDbUrl: eissn: 1573-1367 dateEnd: 20171231 omitProxy: false ssIdentifier: ssj0010074 issn: 0963-9314 databaseCode: BENPR dateStart: 19970101 isFulltext: true titleUrlDefault: https://www.proquest.com/central providerName: ProQuest – providerCode: PRVPQU databaseName: Proquest Research Library customDbUrl: eissn: 1573-1367 dateEnd: 20171231 omitProxy: false ssIdentifier: ssj0010074 issn: 0963-9314 databaseCode: M2O dateStart: 19970101 isFulltext: true titleUrlDefault: https://search.proquest.com/pqrl providerName: ProQuest – providerCode: PRVAVX databaseName: SpringerLINK Contemporary 1997-Present customDbUrl: eissn: 1573-1367 dateEnd: 99991231 omitProxy: false ssIdentifier: ssj0010074 issn: 0963-9314 databaseCode: RSV dateStart: 19970101 isFulltext: true titleUrlDefault: https://link.springer.com/search?facet-content-type=%22Journal%22 providerName: Springer Nature |
| link | http://cvtisr.summon.serialssolutions.com/2.0.0/link/0/eLvHCXMwnV3db9QwDLfYxgMvjE9xsJ2CBC-gSk3SpClv29iEhDhOA8bGS5Sv3iaxFl3v4N_H6bU9NgESvESK6qapY8duHf8M8MwyJa1H_WZWpUlGLU-sC9j1tnDUMWGNaYtN5JOJOj0tpl0ed9Ofdu9Dku1OvU52oywm3FCRFCiVSb4BW2jtVNTG4w8nQ-ggGsUWYE9yJKRZH8r83RBXjdHawxyCotcARFujc7T9X9O9A7c7H5PsrYTiLtwI1T3Y7us3kE6d74OmKTlDSW9IXZIO9eec1BXxwS7jn-gZwa9lt0JwIqbypD1-GIEvSYPb9w8zD6-IIWs0aHJpIt7DjLSotQ_g09Hhx4M3SVdwIXFcyUVSmjJIGkTgQvIgeC6ELDKhnFLBSelLUeaGspBJFVEmbYkKnznuaMlK5ZXjD2GzqqvwCIiUQnhvOdpgdBqDM1SZEFOnTGqddW4Eac957To08lgU46te4yhHBmpkoI4M1PkIXgy3fFtBcfyNeKdfTt1pZaPb8ls8LVg6gqfDZdSnGCQxVaiXkUZllOb4giN42a_sL0P8-YHPV5IyzC0Cd7--ONnT9XymL_25RmGkxeN_GvUJ3GLRj2gPve3A5mK-DLtw031fXDTzMWzkn8_GsLV_OJkeY-9tnmD7Lj2ILXuP7VR8Gbfq8RNa0gQy |
| linkProvider | Springer Nature |
| linkToHtml | http://cvtisr.summon.serialssolutions.com/2.0.0/link/0/eLvHCXMw1V1Lb9QwEB6VggQXyqvqQgEj0QsoIrZjx6mEUNVStWpZcSionIxf2VaiSdnsUvGn-huxnccCEr31wDGy49jxN-OxZ_wNwEtNBNfWyzfRIk0yrGmijfOPVhcGG8K0UjHZRD4ei-Pj4uMSXPZ3YUJYZa8To6K2tQln5G9i6iSaFiR9d_49CVmjgne1T6HRwuLA_bzwW7bm7f6On98NQnbfH23vJV1WgcRQwWdJqUrHsWOOMk4dozljvMiYMEI4w7ktWZkrTFzGRaBS1KVHdWaowSUphRWG-nZvwM0s8-IQQgXT7cFrEdbjyO3HaVJQnPVe1HhVD5NwXQgzX-J38Pmf6-DCuB38sX9xl8b1bnflf_tT9-BuZ1mjrVYU7sOSqx7ASp-1AnVK7CFInKIvvnsNqkvUcR2doLpC1ul5OH-fIFNXpuWtQqqyKAZdBrpP1PhF60JN3SZSaMGBjc5UYLmYoMjV-wg-XcswV2G5qiu3BohzxqzV1Fse3lR2RmGhXLgwplJttDEjSPtJl6bjYA-pQL7JBXt0wIn0OJEBJzIfwavhlfOWgOSqyus9JGSnixq5wMMIXgzFXosE15CqXD0PdUSGce4HOILXPQJ_a-LfH9xoQTr0LdCV75x-3pL1dCLP7In0coCLx1d37Dnc3jv6cCgP98cHT-AOCaZTjPNbh-XZdO6ewi3zY3baTJ9FgUPw9bpx-wu-DGTb |
| linkToPdf | http://cvtisr.summon.serialssolutions.com/2.0.0/link/0/eLvHCXMw1V1Lb9QwEB6VghAXyqtioYCR6AUUNbZjx0FCqGJZUS1a9QConIxf2VaiSdnsUvHX-HXYzmMBid564Bg5cezkm4c9428AnmkiuLZevokWaZJhTRNtnL-0ujDYEKaVisUm8tlMHB0Vhxvwsz8LE9Iqe50YFbWtTdgj34ulk2hakHSv7NIiDseT12ffklBBKkRa-3IaLUSm7se5X741rw7G_l_vEjJ5--HNu6SrMJAYKvgyKVXpOHbMUcapYzRnjBcZE0YIZzi3JStzhYnLuAi0irr0CM8MNbgkpbDCUN_vFbjqrTALMjbNkyGCEWxz5PnjNCkozvqIajy2h0k4OoSZb_Gr-fxPm7h2dIfY7F88ptH2Tbb-5692C252Hjfab0XkNmy46g5s9dUsUKfc7oLEKfrsh9egukQdB9IxqitknV6Fffk5MnVlWj4rpCqLYjJmoAFFjTdm52rhXiKF1tzY6FQF9os5ihy-9-DjpUxzGzarunL3AXHOmLWaeo_Eu9DOKCyUCwfJVKqNNmYEaQ8AaTpu9lAi5Ktcs0oHzEiPGRkwI_MRPB8eOWuJSS66eaeHh-x0VCPX2BjB06HZa5cQMlKVq1fhHpFhnPsJjuBFj8bfuvj3C3dbwA5jCzTm45NP-7JezOWpPZZeJnDx4OKBPYHrHq7y_cFs-hBukOBRxfS_HdhcLlbuEVwz35cnzeJxlD0EXy4btr8As8dtgQ |
| openUrl | ctx_ver=Z39.88-2004&ctx_enc=info%3Aofi%2Fenc%3AUTF-8&rfr_id=info%3Asid%2Fsummon.serialssolutions.com&rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&rft.genre=article&rft.atitle=10+Years+of+research+on+debugging+concurrent+and+multicore+software%3A+a+systematic+mapping+study&rft.jtitle=Software+quality+journal&rft.au=Abbaspour+Asadollah%2C+Sara&rft.au=Sundmark%2C+Daniel&rft.au=Eldh%2C+Sigrid&rft.au=Hansson%2C+Hans&rft.date=2017-03-01&rft.issn=0963-9314&rft.eissn=1573-1367&rft.volume=25&rft.issue=1&rft.spage=49&rft.epage=82&rft_id=info:doi/10.1007%2Fs11219-015-9301-7&rft.externalDBID=n%2Fa&rft.externalDocID=10_1007_s11219_015_9301_7 |
| thumbnail_l | http://covers-cdn.summon.serialssolutions.com/index.aspx?isbn=/lc.gif&issn=0963-9314&client=summon |
| thumbnail_m | http://covers-cdn.summon.serialssolutions.com/index.aspx?isbn=/mc.gif&issn=0963-9314&client=summon |
| thumbnail_s | http://covers-cdn.summon.serialssolutions.com/index.aspx?isbn=/sc.gif&issn=0963-9314&client=summon |