Performance OpenGL - Platform Independent Techniques

Performance OpenGL - Platform Independent Techniques

Performance OpenGL Platform Independent Techniques Dave Shreiner Brad Grantham What Youll See Today An in-depth look at the OpenGL pipeline from a performance perspective Techniques for determining where OpenGL application performance bottlenecks are A bunch of simple, good habits for OpenGL applications Performance OpenGL 3

Performance Tuning Assumptions Youre trying to tune an interactive OpenGL application Theres an established metric for estimating the applications performance Consistent frames/second Number of pixels or primitives to be rendered per frame You can change the applications source code Performance OpenGL 4 Errors Skew Performance Measurements OpenGL Reports Errors

Asynchronously OpenGL doesnt tell you when something goes wrong Need to use glGetError() to determine if something went wrong Calls with erroneous parameters will silently set error state and return without completing Performance OpenGL 5 Checking a single command Simple Macro #define CHECK_OPENGL_ERROR( cmd ) \ cmd; \ { GLenum error; \ while ( (error = glGetError()) != GL_NO_ERROR) { \ printf( "[%s:%d] '%s' failed with error %s\n", \

__FILE__, __LINE__, #cmd, \ gluErrorString(error) ); \ } Some limitations on where the macro can be used cant use inside of glBegin() / glEnd() pair Performance OpenGL 6 The OpenGL Pipeline Performance OpenGL 7 Framebuffer Rasterization

Transformation Application (The Macroscopic View) Performance Bottlenecks Bottlenecks are the performance limiting part of the application Application bottleneck Application may not pass data fast enough to the OpenGL pipeline Transform-limited bottleneck OpenGL may not be able to process vertex transformations fast enough Performance OpenGL 8

Performance Bottlenecks (cont.) Fill-limited bottleneck OpenGL may not be able to rasterize primitives fast enough Performance OpenGL 9 There Will Always Be A Bottleneck Some portion of the application will always be the limiting factor to performance If the application performs to expectations, then the bottleneck isnt a problem Otherwise, need to be able to identify which part of the application is the bottleneck

Well work backwards through the OpenGL pipeline in resolving bottlenecks Performance OpenGL 10 Fill-limited Bottlenecks System cannot fill all the pixels required in the allotted time Easiest bottleneck to test Reduce number of pixels application must fill Make the viewport smaller Performance OpenGL 11 Reducing Fill-limited Bottlenecks

The Easy Fixes Make the viewport smaller This may not be an acceptable solution, but its easy Reduce the frame-rate pixels 800 M second pixels 10 . 7 M frame frames 75 second Performance OpenGL pixels 800 M second

pixels 13 . 3 M frame frames 60 second 12 A Closer Look at OpenGLs Rasterization Pipeline Point Rasterization Line Rasterization Triangle Rasterization

Color Sum Texture Mapping Engine (Sep. Specular Color) Bitmap Rasterization To Fragment Tests Pixel Rectangle Rasterization

Performance OpenGL Fog Engine 13 Reducing Fill-limited Bottlenecks (cont.) Point Rasterization Line Rasterization Rasterization Pipeline Cull back facing Triangle Rasterization

Texture Mapping Engine Color Sum Bitmap Rasterization Pixel Rectangle Rasterization polygons Does require all primitives have same facediness Use per-vertex fog, as compared to per-pixel Performance OpenGL 14

Fog Engine To Fragment Tests A Closer Look at OpenGLs Rasterization Pipeline (cont.) Fragments Pixel Ownership Test Depth Buffer Test

Performance OpenGL Scissor Test Blending Alpha Test Stencil Test Dithering Logical Operations 15 Framebuffer

(from previous stages) Reducing Fill-limited Bottlenecks (cont.) Pixel Ownership Test Fragment Pipeline Do less work per pixel Depth Buffer Test Scissor Test

Blending Alpha Test Stencil Test Dithering Logical Operations Disable dithering Depth-sort primitives to reduce depth testing Use alpha test to reject transparent fragments Performance OpenGL saves doing a pixel read-back from the framebuffer in the

blending phase 16 A Closer Look at OpenGLs Pixel Pipeline Pixel Rectangle Pixel Unpacking Type Conversion Pixel Map Texture Memory

Framebuffer Performance OpenGL Pixel Scale & Bias 17 Clamp Working with Pixel Rectangles Texture downloads and Blts OpenGL supports many formats for storing pixel data Signed and unsigned types, floating point Type conversions from storage type to framebuffer / texture memory format occur

automatically Performance OpenGL 18 Pixel Data Conversions 30 25 20 15 10 5 0 Machine 1 Machine 2 GL_BYTE

GL_UNSIGNED_BYTE GL_SHORT GL_INT GL_UNSIGNED_INT GL_FLOAT Performance OpenGL 19 Machine 3 GL_UNSIGNED_SHORT Pixel Data Conversions (cont.) 2.5 2

1.5 1 0.5 0 Machine 1 Machine 2 Machine 3 GL_ UNSIGNED_ SHORT_ 4_ 4_ 4_ 4 GL_ UNSIGNED_ SHORT_ 4_ 4_ 4_ 4_ REV GL_ UNSIGNED_ SHORT_ 5_ 5_ 5_ 1 GL_ UNSIGNED_ SHORT_ 1_ 5_ 5_ 5_ REV GL_ UNSIGNED_ INT_ 8_ 8_ 8_ 8

GL_ UNSIGNED_ INT_ 8_ 8_ 8_ 8_ REV GL_ UNSIGNED_ INT_ 10_ 10_ 10_ 2 GL_ UNSIGNED_ INT_ 2_ 10_ 10_ 10_ REV Performance OpenGL 20 Pixel Data Conversions (cont.) Observations Signed data types probably arent optimized OpenGL clamps colors to [0, 1] Match pixel format to windows pixel format for blts Usually involves using packed pixel formats No significant difference for rendering speed for textures internal format

Performance OpenGL 21 Fragment Operations and Fill Rate The more you do, the less you get The more work per pixel, the less fill you get Performance OpenGL 22 Fragment Operations and Fill Rate (contd) Machine 2 43

46 49 52 55 58 61 64 46 49 52 55

58 61 64 37 34 31 28 40 40 37 34

31 28 25 22 19 16 13 10 7 1

64 61 58 55 52 49 46 43 40 0.00% 37

0.00% 34 20.00% 31 20.00% 28 40.00% 25 40.00% 22

60.00% 19 60.00% 16 80.00% 13 80.00% 10 100.00% 7 100.00%

4 120.00% 4 Percentage of Peak Fill 120.00% 1 25 Machine 3 Percentage of Peak Fill Performance OpenGL

43 Machine 1 22 19 16 13 7 1 64 61 58

55 52 49 46 43 40 37 34 0.00% 31

0.00% 28 20.00% 25 20.00% 22 40.00% 19 40.00% 16 60.00%

13 60.00% 7 80.00% 10 80.00% 4 100.00% 1 100.00%

10 Percentage of Peak Fill 120.00% 4 Pecentage of Peak Fill 120.00% Machine 4 23 Texture-mapping Considerations Use Texture Objects Allows OpenGL to do texture memory management Loads texture into texture memory when appropriate Only convert data once

Provides queries for checking if a texture is resident Load all textures, and verify they all fit simultaneously Performance OpenGL 24 Texture-mapping Considerations (cont.) Texture Objects (cont.) Assign priorities to textures Provides hints to texture-memory manager on which textures are most important Can be shared between OpenGL contexts Allows one thread to load textures; other thread to render using them Requires OpenGL 1.1

Performance OpenGL 25 Texture-mapping Considerations (cont.) Sub-loading Textures Only update a portion of a texture Reduces bandwidth for downloading textures Usually requires modifying texture-coordinate matrix Performance OpenGL 26 Texture-mapping Considerations (cont.) Know what sizes your textures need to be What sizes of mipmaps will you need? OpenGL 1.2 introduces texture level-of-detail

Ability to have fine grained control over mipmap stack Only load a subset of mipmaps Control which mipmaps are used Performance OpenGL 27 What If Those Options Arent Viable? Use more or faster hardware Utilize the extra time in other parts of the application Transform pipeline tessellate objects for smoother appearance use better lighting Application more accurate simulation

better physics Performance OpenGL 28 Transform-limited Bottlenecks System cannot process all the vertices required in the allotted time If application doesnt speed up in fill-limited test, its most likely transform-limited Additional tests include Disable lighting Disable texture coordinate generation Performance OpenGL

29 A Closer Look at OpenGLs Transformation Pipeline Texture Coordinate Transform Color Texture Coordinate Generation Texture Coordinates Lighting Normals

Vertex Coordinates Performance OpenGL ModelView Transform Lighting 30 Projection Transform Clipping Reducing Transformlimited Bottlenecks Do less work per-vertex Tune lighting Use typed OpenGL matrices

Use explicit texture coordinates Simulate features in texturing lighting Performance OpenGL 31 Lighting Considerations Use infinite (directional) lights Less computation compared to local (point) lights Dont use GL_LIGHTMODEL_LOCAL_VIEWER Use fewer lights Not all lights may be hardware accelerated Performance OpenGL 32

Lighting Considerations (cont.) Use a texture-based lighting scheme Only helps if youre not fill-limited Performance OpenGL 33 Reducing Transformlimited Bottlenecks (cont.) Matrix Adjustments Use typed OpenGL matrix calls Typed Untyped glRotate*() glScale*() glTranslate*() glLoadIdentity()

glLoadMatrix*() glMultMatrix*() Some implementations track matrix type to reduce matrix-vector multiplication operations Performance OpenGL 34 Application-limited Bottlenecks When OpenGL does all you ask, and your application still runs too slow System may not be able to transfer data to OpenGL fast enough Test by modifying application so that no rendering is performed, but all data is still transferred to OpenGL

Performance OpenGL 35 Application-limited Bottlenecks (cont.) Rendering in OpenGL is triggered when vertices are sent to the pipe Send all data to pipe, just not necessarily in its original form Replace all glVertex*() and glColor*() calls with glNormal*() calls glNormal*() only sets the current vertexs normal values Application transfers the same amount of data to the pipe, but doesnt have to wait for rendering to complete Performance OpenGL

36 Reducing Applicationlimited Bottlenecks No amount of OpenGL transform or rasterization tuning will help the problem Revisit application design decisions Data structures Traversal methods Storage formats Use an application profiling tool (e.g. pixie & prof, gprof, or other similar tools) Performance OpenGL 37 The Novice OpenGL Programmers View of the World

Set State Performance OpenGL Render 38 What Happens When You Set OpenGL State The amount of work varies by operation Turning on or off a Set the features enable feature (glEnable() ) flag ( Set a typed set of Set values in OpenGLs data

context (glMaterialfv()) Transfer untyped data (glTexImage2D()) Transfer and convert data from host format into internal representation But all request a validation at next rendering operation Performance OpenGL 39 A (Somewhat) More Accurate Representation Validation

Set State Performance OpenGL Render 40 Validation OpenGLs synchronization process Validation occurs in the transition from state setting to rendering glMaterial( GL_FRONT, GL_DIFFUSE, blue ); glEnable( GL_LIGHT0 ); glBegin( GL_TRIANGLES ); Not all state changes trigger a validation Vertex data (e.g. color, normal, texture coordinates) Changing rendering primitive

Performance OpenGL 41 What Happens in a Validation Changing state may do more than just set values in the OpenGL context May require reconfiguring the OpenGL pipeline selecting a different rasterization routine enabling the lighting machine Internal caches may be recomputed Performance OpenGL vertex / viewpoint independent data 42

The Way it Really Is (Conceptually) Different Rendering Primitive Validation Set State Performance OpenGL Render 43 Why Be Concerned About Validations? Validations can rob performance

from an application Redundant state and primitive changes Validation is a two-step process Determine what data needs to be updated Select appropriate rendering routines based on enabled features Performance OpenGL 44 How Can Validations Be Minimized? Be Lazy Change state as little as possible Try to group primitives by type Beware of under the covers state changes GL_COLOR_MATERIAL Performance OpenGL

may force an update to the lighting cache ever call to glColor*() 45 How Can Validations Be Minimized? (cont.) Beware of glPushAttrib() / glPopAttrib() Very convenient for writing libraries Saves lots of state when called All elements of an attribute groups are copied for later Almost guaranteed to do a validation when calling glPopAttrib() Performance OpenGL 46 State Sorting

Simple technique Big payoff Arrange rendering sequence to minimize state changes Group primitives based on their state attributes Organize rendering based on the expense of the operation Performance OpenGL 47 State Sorting (cont.) Most Expensive Texture Download Modifying Lighting Parameters

Matrix Operations Vertex Data Performance OpenGL Least Expensive 48 A Comment on Encapsulation An Extremely Handy Design Mechanism, however Encapsulation may affect performance Tendency to want to complete all operations for an object before continuing to next object limits state sorting potential may cause unnecessary validations

Performance OpenGL 49 A Comment on Encapsulation (cont.) Using a visitor type pattern can reduce state changes and validations Usually a two-pass operation Traverse objects, building a list of rendering primitives by state and type Render by processing lists Popular method employed by many scene-graph packages Performance OpenGL

50 Scene Graph Lessons Can you use pre-packaged software? Save yourself some trouble Lessons learned from scene graphs Inventor OpenRM DirectModel Cosmo3D DirectSceneGraph/Fahrenheit Performance OpenGL 51 Performer OpenSG

Scene Graph Lessons Organization is the key Organize scene data for performance E.g. by transformation & bounding hierarchy All about balance (like all high-perf coding) Speed versus convenience Portability versus speed Performance OpenGL 52 Performance Goals Identify performance techniques and goals Sort to eliminate costly state changes Evaluate state lazily Dont set state if wont draw geometry Eliminate redundance Dont set red if material is already red

Performance OpenGL 53 Feature Goals Identify algorithms and requirements E.g. Sort alpha/transparent shapes back-tofront Identify multiple rendering passes Shadow texture Environment Map Will you need threading? Performance OpenGL 54 Scene Graph Lessons Put units of work in nodes/leaves Speed of traversal vs. convenience

Instancing e.g. Vertex Arrays, Material, Primitives Do work where you have the information needed e.g. don't require leaf info before traversal Performance OpenGL 55 Scene Graph Lessons Data (Nodes) versus operation (Action) VertexSet::Draw() might be too inflexible Renderer::draw(Node*)allows more flexibility Write new Renderer without changing nodes Performance OpenGL

56 Scene Graph Lessons Data (Nodes) versus operation (Action) Might take a little thought - but beneficial Gives you flexibility for future Need to keep careful eye on performance Performance OpenGL 57 Example Data Structure Directed Graph / Tree Internal and leaf Nodes Subclassing Render Traversal Use bounding volumes OpenGL state management

Performance OpenGL 58 Example Group Group VertexSet PixelState Shape VertexState Performance OpenGL 59

Internal Nodes Represent spatial organization Bounding hierarchy, spatial grid, etc Might encode some functionality Animation Level of Detail Performance OpenGL 60 Internal Nodes Opportunities from bounding volumes View frustum cull (early if using a hierarchy) Screen space size estimation e.g. for level-of-detail or subdivision Ray/picking optimizations Performance OpenGL

61 Leaf Nodes Make leaf data approximate OpenGL state Rapid application from leaf to OpenGL But encode some abstraction Inventors SoComplexity EnvironmentMap instead of assuming GL_SPHERE_MAP Allow optimizations on specific platforms Performance OpenGL 62 Example: VertexSet class VertexSet { GLenum fmt float *verts;

int vertCount; }; Performance OpenGL 63 Example: VertexState class VertexState { Material *Mtl; Lighting *Lighting; ClipPlane *Planes; ... }; Performance OpenGL 64 Example: Node class Node

Volume ... }; Performance OpenGL { Bounds; 65 Example: Shape class Shape : Node { VertexSet *Verts; VertexState *VState; PixelState *PState; int PrimLengths[]; Glenum PrimTypes[]; int *PrimIndices; ... };

Performance OpenGL 66 Example: Group class Group : Node { int ChildCount; Node Children[]; ... }; Performance OpenGL 67 OpenGL Context Encapsulation Bundles of OpenGL state Items commonly changed together texture

fragment ops lighting material vertex arrays shaders Performance OpenGL 68 Example: OpenGLRenderer This is where you evaluate lazily and skip redundant state changes class OpenGLRenderer : Traversal { virtual void Traverse(Node *root); private:

void Schedule (float mtx[16], Shape *shape); void Finish(void); ... }; Performance OpenGL 69 Example: OpenGLRenderer OpenGLRenderer::Traverse(root) Recursive traversal - call from app Check bounding volume Accumulate transformation matrix private OpenGLRenderer::Schedule(mtx, shape) Schedule a shape for rendering private OpenGLRenderer::Finish() State sort by bundle Sort transparent objs back to front Draw all the objects

Performance OpenGL 70 Case Study: Rendering A Cube More than one way to render a cube Render 100000 cubes Render two quads, and one quad-strip Render six separate quads Performance OpenGL 71 Case Study: Method 1

Once for each cube glColor3fv( color ); for ( i = 0; i < NUM_CUBE_FACES; ++i ) { glBegin( GL_QUADS ); glVertex3fv( cube[cubeFace[i][0]] ); glVertex3fv( cube[cubeFace[i][1]] ); glVertex3fv( cube[cubeFace[i][2]] ); glVertex3fv( cube[cubeFace[i][3]] ); glEnd(); } Performance OpenGL 72 Case Study: Method 2 Once for each cube glColor3fv( color ); glBegin( GL_QUADS ); for ( i = 0; i < NUM_CUBE_FACES; ++i ) { glVertex3fv( cube[cubeFace[i][0]] );

glVertex3fv( cube[cubeFace[i][1]] ); glVertex3fv( cube[cubeFace[i][2]] ); glVertex3fv( cube[cubeFace[i][3]] ); } glEnd(); Performance OpenGL 73 Case Study: Method 3 glBegin( GL_QUADS ); for ( i = 0; i < numCubes; ++i ) { for ( i = 0; i < NUM_CUBE_FACES; ++i ) { glVertex3fv( cube[cubeFace[i][0]] ); glVertex3fv( cube[cubeFace[i][1]] ); glVertex3fv( cube[cubeFace[i][2]] ); glVertex3fv( cube[cubeFace[i][3]] ); } } glEnd();

Performance OpenGL 74 Case Study: Method 4 Once for each cube glBegin( GL_QUAD_STRIP ); for ( i = 2; i < NUM_CUBE_FACES; ++i ) { glVertex3fv( cube[cubeFace[i][0]] ); glVertex3fv( cube[cubeFace[i][1]] ); } glVertex3fv( cube[cubeFace[2][0]] ); glVertex3fv( cube[cubeFace[2][1]] ); glEnd(); glColor3fv( color ); glBegin( GL_QUADS ); glVertex3fv( cube[cubeFace[0][0]] glVertex3fv( cube[cubeFace[0][1]] glVertex3fv( cube[cubeFace[0][2]]

glVertex3fv( cube[cubeFace[0][3]] glVertex3fv( glVertex3fv( glVertex3fv( glVertex3fv( glEnd(); cube[cubeFace[1][0]] cube[cubeFace[1][1]] cube[cubeFace[1][2]] cube[cubeFace[1][3]] Performance OpenGL ); ); ); ); ); ); );

); 75 Case Study: Method 5 glBegin( GL_QUADS ); for ( i = 0; i < numCubes; ++i ) { Cube& cube = cubes[i]; glColor3fv( color[i] ); for ( i = 0; i < numCubes; ++i ) { Cube& cube = cubes[i]; glColor3fv( color[i] ); glVertex3fv( glVertex3fv( glVertex3fv( glVertex3fv( cube[cubeFace[0][0]] cube[cubeFace[0][1]]

cube[cubeFace[0][2]] cube[cubeFace[0][3]] ); ); ); ); glVertex3fv( glVertex3fv( glVertex3fv( glVertex3fv( cube[cubeFace[1][0]] cube[cubeFace[1][1]] cube[cubeFace[1][2]] cube[cubeFace[1][3]] ); ); );

); glBegin( GL_QUAD_STRIP ); for ( i = 2; i < NUM_CUBE_FACES; ++i ) { glVertex3fv( cube[cubeFace[i][0]] ); glVertex3fv( cube[cubeFace[i][1]] ); } glVertex3fv( cube[cubeFace[2][0]] ); glVertex3fv( cube[cubeFace[2][1]] ); glEnd(); } } glEnd(); Performance OpenGL 76 Case Study: Results 2.0

1.8 1.6 1.4 1.2 1.0 0.8 0.6 0.4 0.2 0.0 Performance OpenGL Method 1 Method 2 Method 3 Method 4 Method 5 Machine 1 Machine 2 Machine 3

77 Rendering Geometry OpenGL has four ways to specify vertex-based geometry Immediate mode Display lists Vertex arrays Interleaved vertex arrays Performance OpenGL 78 Rendering Geometry (cont.) Not all ways are created equal 3.5 3 2.5

Immediate Display List 2 Array Element Draw Array 1.5 Draw Elements Interleaved Array Element 1 Interleaved Draw Array Interleaved Draw Elements 0.5 0 Machine 1

Performance OpenGL Machine 2 Machine 3 79 Rendering Geometry (cont.) Add lighting and color material to the mix 6 5 Immediate 4 Display List Array Element

3 Draw Array Draw Elements 2 Interleaved Array Element Interleaved Draw Array 1 Interleaved Draw Elements 0 Machine 1 Performance OpenGL Machine 2 Machine 3

80 Case Study: Application Description 1.02M Triangles 507K Vertices Vertex Arrays Colors Normals Coordinates Color Material Performance OpenGL 81 Case Study: Whats the Problem? Low frame rate On a machine capable of 13M

polygons/second application was getting less than 1 frame/second 13.1 M 1.02 M polygons second triangles frame frames 12 second Application wasnt fill limited Performance OpenGL 82 Case Study: The

Rendering Loop Vertex Arrays glVertexPointer( GL_VERTEX_POINTER ); glNormalPointer( GL_NORMAL_POINTER ); glColorPointer( GL_COLOR_POINTER ); glDrawElements() index based rendering Color Material glColorMaterial( GL_FRONT, GL_AMBIENT_AND_DIFFUSE ); Performance OpenGL 83 Case Study: What To Notice Color Material changes two lighting material components per glColor*() call Not that many colors used in the model

18 unique colors, to be exact (3 * 1020472 18) = 3061398 redundant color calls per frame Performance OpenGL 84 Case Study: Conclusions A little state sorting goes a long way Sort triangles based on color Rewriting the rendering loop slightly for ( i = 0; i < numColors; ++i ) { glColor3fv( color[i] ); glDrawElements( , trisForColor[i] ); } Frame rate increased to six frames/second 500% performance increase

Performance OpenGL 85 Summary Know the answer before you start Understand rendering requirements of your applications Have a performance goal Utilize applicable benchmarks Estimate what the hardwares capable of Organize rendering to minimize OpenGL validations and other work Performance OpenGL 86 Summary (cont.) Pre-process data

Convert images and textures into formats which dont require pixel conversions Pre-size textures Simultaneously fit into texture memory Mipmaps Determine whats the best format for sending data to the pipe Performance OpenGL 87 Questions & Answers Thanks for coming Updates to notes and slides will be available at http://www.plunk.org/Performance.OpenGL Feel free to email if you have questions Dave Shreiner

[email protected] Brad Grantham [email protected] Performance OpenGL 88 References OpenGL Programming Guide, 3rd Edition Woo, Mason et. al., Addison Wesley OpenGL Reference Manual, 3rd Edition OpenGL Architecture Review Board, Addison Wesley OpenGL Specification, Version 1.4 OpenGL Architecture Review Board Performance OpenGL

89 For More Information SIGGRAPH 2002 Course # 3 - Developing Efficient Graphics Software SIGGRAPH 2000 Course # 32 - Advanced Graphics Programming Techniques Using OpenGL Performance OpenGL 90 Acknowledgements A Big Thank You to Peter Shaheen for a number of the benchmark programs David Shirley for Case Study application

Performance OpenGL 91

Recently Viewed Presentations

  • Assessment Arrangements update Purpose of this session:  Update

    Assessment Arrangements update Purpose of this session: Update

    We will also continue to use past papers for revision. Within key stages, we will continue to assess what pupils understand and can do in a way that best suits our school. We will report . the pupil's scaled score...
  • Realist international relations theory

    Realist international relations theory

    The agency-structure debate - neo-realists prefer structural explanations. Counterfactuals - contrary-to-fact conditionals. If… then. But must be plausible to be worthwhile. Proximity of cause- how directly was a major event caused by something? Nye distinguishes between proximate, intermediate and deep...
  • PRESENTATION NAME - WordPress.com

    PRESENTATION NAME - WordPress.com

    Can Appearances Deceive? Cute doesn't always mean cuddly, and frightening doesn't always mean vicious. Appearances can deceive, as you will find out when you read "What Do You Know About Sharks?" What are some sayings that suggest that appearances can...
  • Frog Dissection - Weebly

    Frog Dissection - Weebly

    Place your frog on its back and pin it to the dissecting tray. Make a small cut through the lifted skin with the scissors. BE CAREFUL and only cut the skin layer. Use the scissors to continue the incision up...
  • &quot;Bat Loves the Night&quot;

    "Bat Loves the Night"

    Lesson 22 Day 1. Question of the Day ... It was strange because _____. Read Aloud. Bear Snacks . Usually, bears eat fish, berries, fruits, or honey that they find in wild beehives. There are times, though, when they look...
  • The U.S. Political Spectrum Where do YOU stand?

    The U.S. Political Spectrum Where do YOU stand?

    There is greater overall support in the Democratic party for a moratorium on deporting - or offering a pathway to citizenship to - certain undocumented immigrants. e.g. those with no criminal record, who have lived in the U.S. for 5+...
  • Why Value-Added? - VARC

    Why Value-Added? - VARC

    Value-Added estimates are provided with a confidence interval. Based on the data available for these thirty 4th Grade Reading students, we are 95% confident that the true Value-Added lies between the endpoints of this confidence interval (between 3.2 and 4.4...
  • Plate Tectonics and Igneous Activity

    Plate Tectonics and Igneous Activity

    The magma will then migrate to form either volcanic island arcs (Aleutians) or continental volcanic arcs (Andes and Cascades) Convergent Plate Boundaries History of Cascade Range Volcanism Divergent Plate Boundaries Most magma is produced during seafloor spreading (at the ocean...