Performance analysis of text-oriented printing using PostScript

POSTSCRIPT is a page description language which is used to transmit printing information from a host computer (i.e. Apple Macintosh) to a printer (i.e. Apple LaserWriter Plus). It has the ability to describe pages consisting of text, vector graphics, and scanned bit-map images. Printing text is the area of concentration for this thesis. Specifically several variables that affect the printing speed of a common POSTSCRIPT printer, the Apple LaserWriter Plus, are looked at when printing text in a variety of fonts, sizes, and orientations. The variables that affect printer performance include: - use of outline vs. bit-map fonts; - the outline font rasterization process; - the use of pre-cached bit-map fonts; - background outline font rasterization; - arbitrary scaling and rotation; - downloading host-resident fonts; - Adobe and Third Party host-resident downloadable fonts vs. printer-resident fonts; - Appletalk vs. RS-232 communications interfaces; - use of the POSTSCRIPT show, ashow, and widthshow instructions; - targeting the POSTSCRIPT instructions at a particular engine resolution; - print engine overhead A sequence of POSTSCRIPT files were transmitted to the Apple LaserWriter Plus printer. The experiments were carefully constructed to exercize each of the variables listed above. Performance measurements were carefully recorded and analyzed. Where applicable, improvements were proposed to improve printer performance

Efficient software development for microprocessor based embedded system.

Tang Tze Yeung Eric.Thesis submitted in: July 2003.Thesis (M.Phil.)--Chinese University of Hong Kong, 2004.Includes bibliographical references (leaves 69-75).Abstracts in English and Chinese.ABSTRACT --- p.IIACKNOWLEDGMENT --- p.IIChapter 1 --- INTRODUCTION --- p.1Chapter 1.1 --- Embedded System --- p.1Chapter 1.2 --- Embedded Processor --- p.1Chapter 1.3 --- Embedded System Design --- p.3Chapter 1.3.1 --- Current Embedded System Design Challenges --- p.3Chapter 1.3.2 --- Embedded System Design Trend --- p.4Chapter 1.4 --- Efficient Software Development for Microprocessor --- p.8Chapter 1.4.1 --- Efficient Software Development Methodology --- p.8Chapter 1.5 --- Thesis Organization --- p.10Chapter 2 --- SOURCE CODE OPTIMIZATION --- p.11Chapter 2.1 --- Source Code Optimization Strategy --- p.11Chapter 2.2 --- Source Code Transformations --- p.12Chapter 2.2.1 --- Strength Reduction --- p.12Chapter 2.2.2 --- Function Inlining --- p.13Chapter 2.2.3 --- Table Lookup --- p.13Chapter 2.2.4 --- Loop Transformations --- p.13Chapter 2.2.5 --- Software Pipelining --- p.15Chapter 2.2.6 --- Register Allocation --- p.17Chapter 2.3 --- Case Study: Source Code Optimization on the StrongARM (SA1110) Platform --- p.18Chapter 2.3.1 --- StrongARM architecture --- p.18Chapter 2.3.2 --- StrongARM pipeline hazard illustration --- p.20Chapter 2.3.3 --- Source Code Optimization on StrongARM --- p.21Chapter 2.3.4 --- Instruction Set Optimization of StrongARM --- p.27Chapter 2.4 --- Conclusion --- p.32Chapter 3 --- FLOAT-TO-FIXED OPTIMIZATION --- p.33Chapter 3.1 --- Introduction to Fixed-point --- p.34Chapter 3.1.1 --- Fixed-point representation --- p.34Chapter 3.1.2 --- Fixed-point implementation --- p.35Chapter 3.1.3 --- Mathematical functions implementation --- p.38Chapter 3.2 --- Case Study: Fingerprint Minutiae Extraction Algorithms on the Strong ARM platform --- p.41Chapter 3.2.1 --- Fingerprint Verification Overview --- p.42Chapter 3.2.2 --- Fixed-point Implementation of Fingerprint Minutiae Extraction Algorithm --- p.49Chapter 3.2.3 --- Experimental Results --- p.51Chapter 3.3 --- Conclusion --- p.56Chapter 4 --- DOMAIN SPECIFIC OPTIMIZATION --- p.57Chapter 4.1 --- Case Study: Font Rasterization on the Strong ARM platform --- p.57Chapter 4.1.1 --- Outline Font --- p.57Chapter 4.1.2 --- Font Rasterization --- p.59Chapter 4.1.3 --- Experiments --- p.63Chapter 4.2 --- Conclusion --- p.66Chapter 5 --- CONCLUSION --- p.67BIBLIOGRAPHY --- p.6

Robust object-based algorithms for direct shadow simulation

En informatique graphique, les algorithmes de générations d'ombres évaluent la quantité de lumière directement perçue par une environnement virtuel. Calculer précisément des ombres est cependant coûteux en temps de calcul. Dans cette dissertation, nous présentons un nouveau système basé objet robuste, qui permet de calculer des ombres réalistes sur des scènes dynamiques et ce en temps interactif. Nos contributions incluent notamment le développement de nouveaux algorithmes de génération d'ombres douces ainsi que leur mise en oeuvre efficace sur processeur graphique. Nous commençons par formaliser la problématique du calcul d'ombres directes. Tout d'abord, nous définissons ce que sont les ombres directes dans le contexte général du transport de la lumière. Nous étudions ensuite les techniques interactives qui génèrent des ombres directes. Suite à cette étude nous montrons que mêmes les algorithmes dit physiquement réalistes se reposent sur des approximations. Nous mettons également en avant, que malgré leur contraintes géométriques, les algorithmes d'ombres basées objet sont un bon point de départ pour résoudre notre problématique de génération efficace et robuste d'ombres directes. Basé sur cette observation, nous étudions alors le système basé objet existant et mettons en avant ses problèmes de robustesse. Nous proposons une nouvelle technique qui améliore la qualité des ombres générées par ce système en lui ajoutant une étape de mélange de pénombres. Malgré des propriétés et des résultats convaincants, les limitations théoriques et de mise en oeuvre limite la qualité générale et les performances de cet algorithme. Nous présentons ensuite un nouvel algorithme d'ombres basées objet. Cet algorithme combine l'efficacité de l'approche basée objet temps réel avec la précision de sa généralisation au rendu hors ligne. Notre algorithme repose sur l'évaluation locale du nombre d'objets entre deux points : la complexité de profondeur. Nous décrivons comment nous utilisons cet algorithme pour échantillonner la complexité de profondeur entre les surfaces visibles d'une scène et une source lumineuse. Nous générons ensuite des ombres à partir de cette information soit en modulant l'éclairage direct soit en intégrant numériquement l'équation d'illumination directe. Nous proposons ensuite une extension de notre algorithme afin qu'il puisse prendre en compte les ombres projetées par des objets semi-opaque. Finalement, nous présentons une mise en oeuvre efficace de notre système qui démontre que des ombres basées objet peuvent être générées de façon efficace et ce même sur une scène dynamique. En rendu temps réel, il est commun de représenter des objets très détaillés encombinant peu de triangles avec des textures qui représentent l'opacité binaire de l'objet. Les techniques de génération d'ombres basées objet ne traitent pas de tels triangles dit "perforés". De par leur nature, elles manipulent uniquement les géométries explicitement représentées par des primitives géométriques. Nous présentons une nouvel algorithme basé objet qui lève cette limitation. Nous soulignons que notre méthode peut être efficacement combinée avec les systèmes existants afin de proposer un système unifié basé objet qui génère des ombres à la fois pour des maillages classiques et des géométries perforées. La mise en oeuvre proposée montre finalement qu'une telle combinaison fournit une solution élégante, efficace et robuste à la problématique générale de l'éclairage direct et ce aussi bien pour des applications temps réel que des applications sensibles à la la précision du résultat.Direct shadow algorithms generate shadows by simulating the direct lighting interaction in a virtual environment. The main challenge with the accurate direct shadow problematic is its computational cost. In this dissertation, we develop a new robust object-based shadow framework that provides realistic shadows at interactive frame rate on dynamic scenes. Our contributions include new robust object-based soft shadow algorithms and efficient interactive implementations. We start, by formalizing the direct shadow problematic. Following the light transport problematic, we first formalize what are robust direct shadows. We then study existing interactive direct shadow techniques and outline that the real time direct shadow simulation remains an open problem. We show that even the so called physically plausible soft shadow algorithms still rely on approximations. Nevertheless we exhibit that, despite their geometric constraints, object-based approaches seems well suited when targeting accurate solutions. Starting from the previous analyze, we investigate the existing object-based shadow framework and discuss about its robustness issues. We propose a new technique that drastically improve the resulting shadow quality by improving this framework with a penumbra blending stage. We present a practical implementation of this approach. From the obtained results, we outline that, despite desirable properties, the inherent theoretical and implementation limitations reduce the overall quality and performances of the proposed algorithm. We then present a new object-based soft shadow algorithm. It merges the efficiency of the real time object-based shadows with the accuracy of its offline generalization. The proposed algorithm lies onto a new local evaluation of the number of occluders between $two$ points (\ie{} the depth complexity). We describe how we use this algorithm to sample the depth complexity between any visible receiver and the light source. From this information, we compute shadows by either modulate the direct lighting or numerically solve the direct illumination with an accuracy depending on the light sampling strategy. We then propose an extension of our algorithm in order to handle shadows cast by semi opaque occluders. We finally present an efficient implementation of this framework that demonstrates that object-based shadows can be efficiently used on complex dynamic environments. In real time rendering, it is common to represent highly detailed objects with few triangles and transmittance textures that encode their binary opacity. Object-based techniques do not handle such perforated triangles. Due to their nature, they can only evaluate the shadows cast by models whose their shape is explicitly defined by geometric primitives. We describe a new robust object-based algorithm that addresses this main limitation. We outline that this method can be efficiently combine with object-based frameworks in order to evaluate approximative shadows or simulate the direct illumination for both common meshes and perforated triangles. The proposed implementation shows that such combination provides a very strong and efficient direct lighting framework, well suited to many domains ranging from quality sensitive to performance critical applications

3D APIs in Interactive Real-Time Systems: Comparison of OpenGL, Direct3D and Java3D.

Since the first display of a few computer-generated lines on a Cathode-ray tube (CRT) over 40 years ago, graphics has progressed rapidly towards the computer generation of detailed images and interactive environments in real time (Angel, 1997). In the last twenty years a number of Application Programmer's Interfaces (APIs) have been developed to provide access to three-dimensional graphics systems. Currently, there are numerous APIs used for many different types of applications. This paper will look at three of these: OpenGL, Direct3D, and one of the newest entrants, Java3D. They will be discussed in relation to their level of versatility, programability, and how innovative they are in introducing new features and furthering the development of 3D-interactive programming

Towards a filmic look and feel in real time computer graphics

Film footage has a distinct look and feel that audience can instantly recognize, making its replication desirable for computer generated graphics. This thesis presents methods capable of replicating significant portions of the film look and feel while being able to fit within the constraints imposed by real-time computer generated graphics on consumer hardware

DISTWAR: Fast Differentiable Rendering on Raster-based Rendering Pipelines

Differentiable rendering is a technique used in an important emerging class of visual computing applications that involves representing a 3D scene as a model that is trained from 2D images using gradient descent. Recent works (e.g. 3D Gaussian Splatting) use a rasterization pipeline to enable rendering high quality photo-realistic imagery at high speeds from these learned 3D models. These methods have been demonstrated to be very promising, providing state-of-art quality for many important tasks. However, training a model to represent a scene is still a time-consuming task even when using powerful GPUs. In this work, we observe that the gradient computation phase during training is a significant bottleneck on GPUs due to the large number of atomic operations that need to be processed. These atomic operations overwhelm atomic units in the L2 partitions causing stalls. To address this challenge, we leverage the observations that during the gradient computation: (1) for most warps, all threads atomically update the same memory locations; and (2) warps generate varying amounts of atomic traffic (since some threads may be inactive). We propose DISTWAR, a software-approach to accelerate atomic operations based on two key ideas: First, we enable warp-level reduction of threads at the SM sub-cores using registers to leverage the locality in intra-warp atomic updates. Second, we distribute the atomic computation between the warp-level reduction at the SM and the L2 atomic units to increase the throughput of atomic computation. Warps with many threads performing atomic updates to the same memory locations are scheduled at the SM, and the rest using L2 atomic units. We implement DISTWAR using existing warp-level primitives. We evaluate DISTWAR on widely used raster-based differentiable rendering workloads. We demonstrate significant speedups of 2.44x on average (up to 5.7x)

Font Rasterization, the State of Art

Modern personal computers and workstations enable text, graphics and images to be visualized in a resolution independent manner. Office documents can be visualized and printed in the same way on displays, page-printers and photocomposers. Personal computers like the PC and the MacIntosh incorporate advanced rasterization algorithms for the rendering of outline characters and graphics. In the nineties, advanced workstations will provide facilities for the generation of finely tuned gray-scale characters. This tutorial provides a survey of the basic algorithms for representing and rendering outline characters. Fast scan-conversion and filling algorithms as well as basic and advanced character outline grid-fitting techniques are presented. The philosophy and functionality of Adobe's Type 1 and Apple's TrueType typographic rendering systems are discussed