SCALABLE GRAPHICS ARCHITECTURES: INTERFACE & TEXTURE A DISSERTATION SUBMITTED TO THE COMPUTER SCIENCE DEPARTMENT AND THE COMMITTEE ON GRADUATE STUDIES OF STANFORD UNIVERSITY IN PARTIAL FULFILLMENT OF THE REQUIREMENTS FOR THE DEGREE OF DOCTOR OF PHILOSOPHY Homan Igehy May 2000 © Copyright by Homan Igehy 2000 All Rights Reserved ii I certify that I have read this dissertation and that in my opinion it is fully adequate, in scope and quality, as a dissertation for the degree of Doctor of Philosophy. ___________________________________ Pat Hanrahan (Principal Advisor) I certify that I have read this dissertation and that in my opinion it is fully adequate, in scope and quality, as a dissertation for the degree of Doctor of Philosophy. ___________________________________ Mark Horowitz I certify that I have read this dissertation and that in my opinion it is fully adequate, in scope and quality, as a dissertation for the degree of Doctor of Philosophy. ___________________________________ Bill Dally Approved for the University Committee on Graduate Studies: ___________________________________ iii iv Abstract With today's technology, it is possible to place a significant amount graphics processing power on a single chip. While this allows computers to render very impressive imagery, many interactive graphics applications require several orders of magnitude more in proc- essing power. Parallelism is one way of achieving increased power, and scalable solu- tions achieve parallelism through the replication of a basic unit. In this dissertation, we discuss scalable graphics architectures and present novel techniques for scaling two im- portant aspects of graphics architectures that have not been addressed by the literature: interface and texture. First, we analyze parallelism in the graphics pipeline. By looking at the virtual ma- chine defined by the graphics API and analyzing its dependencies, we are able to exam- ine the sources of parallelism. We define the metrics of scalability and analyze the extent to which existing graphics architectures are able to scale. Second, we present a novel parallel graphics interface that allows for scalable input rates. This interface allows mul- tiple graphics contexts to simultaneously submit commands to the graphics system while explicitly ordering the drawing of graphics primitives. Even with scenes that require a total order, fully scalable submission and rendering are demonstrated. Finally, we pre- sent a scalable texture architecture based on a shared texture memory. In order to tolerate the high and variable latencies of a shared texture memory, a novel texture prefetching architecture is described. The effects of parallel texture caching are examined in detail, demonstrating the applicability of such an approach across a wide variety of rasterization architectures. v vi Acknowledgements I would like to thank all the people who helped me through my years at Stanford. Be- cause I did my undergraduate education here as well as my graduate education, I have spent 9 years out of my 27 years of life here: one-third of my life. You’ll understand if I forget someone…. First and foremost, I would like to thank my advisor, Pat Hanrahan. Stylistically, he was very much a hands-off advisor that let me pursue my interests. Sometimes this would mean video games and guitar, and sometimes this would mean fruitful research. The research in this dissertation, as well as research beyond the scope of this dissertation, was guided by a person who had the knowledge to push me in the right direction and the wisdom to let me find my way from there. I would also like to thank Bill Dally and Mark Horowitz, the other members of my reading committee. Mark’s comments over the years have always been to the point and have helped me gain a greater technical understanding of the work in this thesis. Bill’s viewpoints called into question many of my assumptions and have helped me gain a better understanding of graphics architectures from a more general perspective. My colleagues in the Stanford graphics lab have been a source of fun and learning. The course project of implementing a graphics pipeline in a class by Marc Levoy sparked my interest in graphics architecture, and I still recall trying to keep up with the torrent pace of lecturing by Leo Guibas in a couple of classes. I also owe a great debt to the other students who helped me with my research over the years, particularly Matthew El- dridge, Gordon Stoll, Kekoa Proudfoot, John Owens, Matt Pharr, Milton Chen, Ian Buck, vii James Davis, Bill Mark, Maneesh Agrawala, Timothy Purcell, Lucas Pereira, Greg Hum- phreys, Afra Zomorodian, and Phil Lacroute. I would like to thank my parents, Jeff and Golie, for their love and support over the years. I would like to thank my brother, Alex, and his fiancée, Dana, for looking out for me over the years. I thank my friends, who have made me laugh through good times and bad times, and I thank Sepi, who puts a smile on my face every day. Finally, I would like to thank DARPA, under contract DABT63-95-C-0085-P00006, and Intel Corporation for the financial support of my research. viii Contents Abstract v Acknowledgements vii Chapter 1 Introduction 1 1.1 Trends in Graphics Architecture .......................................................................... 2 1.2 The Rendering Problem ....................................................................................... 5 1.2.1 Representations and Algorithms .............................................................. 5 1.2.2 Interactive Rendering ............................................................................... 7 1.3 The Graphics Pipeline.......................................................................................... 8 1.4 Summary of Original Contributions................................................................... 14 Chapter 2 Analysis of Parallel Graphics 17 2.1 Sources of Parallelism........................................................................................ 18 2.1.1 Instruction Set........................................................................................ 19 2.1.2 Data Dependencies................................................................................. 21 2.1.2.1 Dependencies and Parallelism.......................................................... 21 2.1.2.2 Data Dependencies in Graphics Architectures................................. 23 2.1.3 Control Dependencies ............................................................................ 26 2.1.4 Discussion .............................................................................................. 27 2.2 Scaling the Graphics Pipeline ............................................................................ 29 ix 2.2.1 Scalability Metrics.................................................................................. 29 2.2.2 Analysis of Scalable Architectures ........................................................ 32 2.2.2.1 Sort-First Architectures.................................................................... 35 2.2.2.2 Sort-Middle Architectures................................................................ 38 2.2.2.3 Fragment-sorting Architectures........................................................ 42 2.2.2.4 Image-Composition Architectures ................................................... 43 2.2.2.5 Pomegranate Architecture................................................................ 45 2.3 Conclusion ......................................................................................................... 48 Chapter 3 Scalable Graphics Interface 49 3.1 Introduction........................................................................................................ 50 3.2 Motivation.......................................................................................................... 51 3.3 Related Work ..................................................................................................... 53 3.4 The Parallel API Extensions .............................................................................. 55 3.4.1 Existing Constructs................................................................................ 56 3.4.2 The Wait Construct ................................................................................ 57 3.4.3 Synchronization Constructs....................................................................58 3.5 Using the Parallel Graphics API ........................................................................ 59 3.5.1 Simple Interactive Loop......................................................................... 60 3.5.2 Marching Cubes..................................................................................... 61 3.6 Implementations................................................................................................. 63 3.6.1 Argus: A Software Implementation ....................................................... 63 3.6.1.1 Architecture...................................................................................... 63 3.6.1.2 Performance ..................................................................................... 67 3.6.2 Pomegranate: A Hardware Implementation........................................... 73 3.6.2.1 Architecture...................................................................................... 73 3.6.2.2 Performance ..................................................................................... 76 3.6.3 WireGL: A Transparent Implementation