MARC

 008250123s2024        us                              c    eng  d
■001000017164859
■00520250211153056
■006m          o    d                
■007cr#unu||||||||
■020    ▼a9798346384687
■035    ▼a(MiAaPQ)AAI31643401
■035    ▼a(MiAaPQ)Stanfordwy858dx3646
■040    ▼aMiAaPQ▼cMiAaPQ
■0820  ▼a741
■1001  ▼aDaly,  Ross.
■24510▼aEfficiently  Synthesizing  a  Complete  Set  of  Unique  Instruction  Selection  Rewrite  Rules  Using  SMT
■260    ▼a[Sl]▼bStanford  University▼c2024
■260  1▼aAnn  Arbor▼bProQuest  Dissertations  &  Theses▼c2024
■300    ▼a87  p
■500    ▼aSource:  Dissertations  Abstracts  International,  Volume:  86-05,  Section:  B.
■500    ▼aAdvisor:  Hanrahan,  Pat.
■5021  ▼aThesis  (Ph.D.)--Stanford  University,  2024.
■520    ▼aWith  the  ever-evolving  landscape  of  computer  architecture,  we  are  witnessing  an  influx  of  novel  intermediate  representations  (IRs)  and  instruction  set  architectures  (ISAs).  These  innovations  often  come  with  the  promise  of  enhanced  performance,  reduced  power  consumption,  and  better  utilization  of  hardware  resources.  However,  to  harness  the  full  potential  of  these  advancements,  the  application  compilers  must  be  updated  or  rewritten  to  provide  custom  support  for  each  target  ISA.  Compilers  must  not  only  produce  correct  translations,  but  must  do  so  while  at  the  same  time  both  optimizing  the  quality  of  the  code  produced  and  maintaining  good  runtime  performance.The  step  that  translates  the  compiler's  intermediate  representation  to  the  target  ISA  is  called  instruction  selection.  The  task  of  instruction  selection  is  to  translate  functions  composed  of  IR  instructions  to  equivalent  functions  composed  of  machine  instructions  (referred  to  in  this  document  as  ISA  instructions).  This  translation  is  to  be  done  optimally  with  respect  to  a  cost  metric  corresponding  to  the  code  quality  of  the  resulting  translation.  The  most  common  way  for  a  compiler  to  perform  this  translation  is  to  use  a  set  of  predefined  rewrite  rules.  Each  rewrite  rule  consists  of  an  IR  pattern  and  a  functionally  equivalent  ISA  pattern.  The  IR  pattern  is  a  code  fragment  that  could  appear  within  an  input  IR  program.  The  instruction  selection  algorithm  first  structurally  matches  a  rewrite  rule's  IR  pattern  to  a  fragment  of  the  IR  code.  It  can  then  choose  to  replace  that  fragment  with  the  rewrite  rule's  ISA  pattern  by  applying  the  rewrite  rule.  The  algorithm  will  try  to  find  a  set  of  rewrite  rule  applications  that  result  in  machine  code  that  is  optimized  with  regards  to  the  cost  metric.Enumerating  these  rewrite  rules  is  a  challenging  task.  Traditionally,  when  designing  a  new  compiler  or  a  new  compiler  back-end,  the  designer  must  construct  these  rewrite  rules  manually.  While  manually  crafting  rewrite  rules  for  a  compiler  system  with  a  particular  Intermediate  Representation  (IR)  and  Instruction  Set  Architecture  (ISA)  is  possible,  it  presents  four  significant  downsides.First,  there  can  be  thousands  of  potential  rewrite  rules,  making  it  highly  inecient  and  laborintensive  to  manually  specify  each  one.Second,  manually  constructing  rewrite  rules  increases  the  likelihood  of  specifying  invalid  rules,  where  the  IR  pattern  is  not  functionally  equivalent  to  the  ISA  pattern.  Using  such  rules  results  in  incorrect  translations  during  compilation.  Ensuring  correctness  is  paramount  in  compiler  design,  and  such  erroneous  translations  must  be  avoided.Third,  it  is  dicult  to  capture  all  important  rewrite  rules.  Missing  rewrite  rules  can  adversely  a↵ect  the  quality  of  instruction  selection  and  translation.  Some  programs  may  not  achieve  optimal  translation  due  to  the  absence  of  essential  rewrite  rules.Fourth,  over-specification  of  rewrite  rules  is  a  common  issue.  Certain  rewrite  rules  may  never  be  used  in  any  optimal  translation,  which  can  slow  down  compilation  time.  A  rewrite  rule  is  redundant  in  a  variety  of  circumstances,  such  as  the  IR  pattern  never  appearing  in  any  program,  the  rewrite  rule  being  more  costly  than  other  similar  rules,  or  the  rewrite  rule  being  a  duplicate  of  one  or  more  other  rules.When  there  are  many  possible  IR  and  ISA  combinations,  manually  crafting  rewrite  rules  is  an  even  greater  e↵ort.  Consider  a  design  space  exploration  tool  which  can  automatically  generate  many  potential  processing  element  architectures  each  of  which  has  its  own  ISA.
■590    ▼aSchool  code:  0212.
■650  4▼aDesign
■650  4▼aSpace  exploration
■650  4▼aSemantics
■650  4▼aAerospace  engineering
■650  4▼aLogic
■690    ▼a0389
■690    ▼a0538
■690    ▼a0395
■71020▼aStanford  University.
■7730  ▼tDissertations  Abstracts  International▼g86-05B.
■790    ▼a0212
■791    ▼aPh.D.
■792    ▼a2024
■793    ▼aEnglish
■85640▼uhttp://www.riss.kr/pdu/ddodLink.do?id=T17164859▼nKERIS▼z이  자료의  원문은  한국교육학술정보원에서  제공합니다.

미리보기

내보내기

chatGPT토론

Ai 추천 관련 도서