text:
|Method for preparing and dynamically loading context files
(a) dividing execution of said target program into a plurality of activities which are based on operation of said target program by an end user, each of said activities requiring invocation of at least one procedure of said target program for completion of said each activity;
(b) for each of said activities, executing said target program and at completion of said each activity, storing profile information for indicating which procedures of said target program were invoked for completion of said each activity; and
(c) placing procedures which are invoked for a particular set of activities in contiguous locations of said target program, based on said profile information stored for each activity.
inverting said activity bit slices so that a bit signature is obtained for each procedure, for indicating which activities each procedure has been invoked for; and
ordering the bit signatures so that procedures having identical bit signatures are clustered together.
(a) dividing the program into a plurality of discrete activities, each activity representing a particular task of the program which occurs during actual use of the program by a user;
(b) for each activity, generating a corresponding bit set, each bit in the bit set representing whether a call has been made to a particular routine during execution of said each activity;
(c) determining a bit signature for each activity, each bit in said bit signature identifying which particular routines of the program have been called during execution of said each activity;
(d) generating an ordered list of all bit signatures, for identifying which particular routines of the program are related based on activity; and
(e) ordering said routines in the computer program according to said ordered list.
for each activity, writing the corresponding bit set to a mass storage device upon completion of said each activity.
storing a handler routine for detecting when execution has begun for each routine of the program; and
upon detecting that execution has begun for a particular routine for a currently executing activity, setting a corresponding bit in the bit set of said currently executing activity for representing that a call has been made to the particular routine during execution of said activity.
generating an ordered list of all bit signatures based on a declining count of how many bits are set in each signature.
generating an ordered list of all bit signatures based on maximization of connectivity of neighboring bit signatures.
generating an ordered list of all bit signatures based on global maximization of connectivity between bit signatures.
ordering said routines in the computer program according to said ordered list, so that routines sharing an identical bit signature are stored contiguously in said page units of the program.
ordering said routines in the computer program according to said ordered list, so that routines sharing an identical bit signature are stored contiguously in a particular code segment of the program.
dividing the program into N number of discrete activities, wherein N number of bits comprises a machine-word storage unit or multiple thereof.
assigning a weighting to each activity for indicating importance of said each activity to execution of the program, so that in step (e), said ordering of said routines in the computer program is based on said ordered list and on said weighting assigned to each activity.
A portion of the disclosure of this patent document contains material which is subject to copyright protection. The copyright owner has no objection to the facsimile reproduction by anyone of the patent document or the patent disclosure as it appears in the Patent and Trademark Office patent file or records, but otherwise reserves all copyright rights whatsoever.
The present invention relates generally to the field of development systems for computers and, more particularly, to systems and methods for compiling source programs into object modules and linking those modules into programs executable by computers.
Before a digital computer may accomplish a desired task, it must receive an appropriate set of instructions. Executed by the computer's microprocessor, these instructions, collectively referred to as a "computer program," direct the operation of the computer. Expectedly, the computer must understand the instructions which it receives before it may undertake the specified activity.
Owing to their digital nature, computers essentially only understand "machine code," i.e., the low-level, minute instructions for performing specific tasks--the sequence of ones and zeros that are interpreted as specific instructions by the computer's microprocessor. Since machine language or machine code is the only language computers actually understand, all other programming languages represent ways of structuring human language so that humans can get computers to perform specific tasks.
While it is possible for humans to compose meaningful programs in machine code, practically all software development today employs one or more of the available programming languages. The most widely used programming languages are the "high-level" languages, such as C or Pascal. Most of the high-level languages currently used for program development exploit the concept of modularity whereby a commonly required set of operations can be encapsulated in a separately named subroutine, procedure, or function; these terms will be used interchangeably herein to represent any type of discrete code objects. Once coded, such subroutines can be reused by "calling" them from any point in the main program. Further, a subroutine may call a subsubroutine, and so on, so that in most cases an executing program is seldom a linear sequence of instructions.
In the C language, for example, a main() program is written which calls a sequence of functions, each of which can call functions, and so on. The essence of a function call is that the calling function (caller) passes relevant data as arguments (or parameters) to the target function (callee), transfers control to the memory section holding the function's executable code, returns the result of the call, and at the same time, stores sufficient information to ensure that subsequent execution resumes immediately after the point where the original function call was made. This approach allows developers to express procedural instructions in a style of writing which is easily read and understood by fellow programmers.
A program called a "compiler" translates these instructions into the requisite machine language. In the context of this translation, the program written in the high-level language is called the "source code" or source program. The ultimate output of the compiler is an "object module," which includes instructions for execution by a target processor. Although an object module includes code for instructing the operation of a computer, the object module itself is not in a form which may be directly executed by a computer. Instead, it must undergo a "linking" operation before the final executable program is created.
Linking may be thought of as the general process of combining or linking together one or more compiled object modules to create an executable program. This task usually falls to a program called a "linker." In typical operation, a linker receives, either from the user or from an integrated compiler, a list of object modules desired to be included in the link operation. The linker scans the object modules from the object and library files specified. After resolving interconnecting references as needed, the linker constructs an executable image by organizing the object code from the modules of the program in a format understood by the operating system program loader. The end result of linking is executable code (typically an .EXE file) which, after testing and quality assurance, is passed to the user with appropriate installation and usage instructions.
Ideally, when a compiler/linker development system translates a description of a program and maps it onto the underlying machine-level instruction set of a target processor, the resulting code should be at least as good as can be written by hand. In reality, code created by straightforward compilation and linking rarely achieves its goal. Instead, tradeoffs of slower performance and/or increased size of the executing application are often incurred. Thus while development systems simplify the task of creating meaningful programs, they rarely produce machine code which is not only the most efficient (smallest) in size but also executes the fastest.
One approach for improving the machine-level code generated for a program is to employ an execution profiler for analyzing the code, looking for any significant performance bottlenecks. Using a profiler, a developer can determine: how many times a particular section of code is executed (i.e., function is called, loop is iterated, and the like) and how long does it take to execute a particular passage of code. A passage executed a million times during operation of a program deserves more attention than one executed only once or twice. Improvements in the former typically have a profound effect on overall program performance, while improvements in the latter probably would yield only marginal improvements.
Profilers typically employ one of two approaches for analyzing a program. In the first approach, the profiler periodically interrupts the program's operation and checks the current location of the program counter. The results are scored using statistical methodology. Although the approach is not difficult to implement, the results are not particularly good. For instance, sections of code which may be of interest might be too small to be sampled accurately. Also, the approach cannot tell reliably how many times a passage was employed. The second approach is to start a system timer when the program reaches a passage of interest and stop the timer when the program leaves the passage. The approach is harder to implement but generally leads to more accurate analysis of the program.
Another avenue for improving performance of a program, one which is of particular interest to the present invention, is optimization of the ordering or layout of various procedures which comprise the executable program. Consider, for instance, programs running under Microsoft MS-DOS on an Intel 80×86-class computer. In the Intel architecture, a program code is organized into discrete blocks of executable code or "code segments." A call from a procedure (subroutine, function, or the like) in one code segment to another procedure residing in a different code segment ("far" call) is computationally more expensive than an intersegment or "near" call (since the CPU must load new segment descriptor information). A program with its procedures arranged within a few large segments requires fewer far calls than if the same program were implemented with many small segments and, thus, generally performs better. Thus, developers for MS-DOS programs may optimize performance by minimizing the number of segments in their programs, in order to minimize the number of intersegment or "far" calls.
Consider, in contrast, programs running under Microsoft Windows on an Intel 80×86-class computer. In a Windows environment, code segments can be dynamically loaded, moved, linked, and discarded. Developers tend to create programs comprising many smaller code segments. Such a program requires less memory than a corresponding version of that program with fewer large segments (as it is easier for the operating system to discard or swap out unused portions of the program). As code segments are needed, they are read from the storage device. When available memory gets low, on the other hand, code segments which are no longer needed are discarded to free up memory.
The foregoing approach is not without drawbacks, however. As more code segments are employed, the likelihood increases that a function or procedure call will be a far call. Moreover, the likelihood increases that a call will be to a procedure which is not yet in memory. Most users of Windows programs are familiar with "thrashing"--a condition in which a program repetitively accesses a storage device before completion of its current task (e.g., storing a spreadsheet file). Here, the current execution path requires execution of procedures strewn across various code segments, ones which cannot all be loaded into available memory. The program must waste time reading, discarding, and re-reading different code segments from the storage device before it executes all the procedures which complete the current task.
Given that programs typically comprise a plurality of interdependent procedures or functions, programs may be optimized by packing together or "clustering" groups of related functions. In this manner, interdependent procedures of a program are more readily available to one another (e.g., stored in the same memory page) at runtime. Although the task of organizing code segments for a program may be done by hand, such an approach is tedious and prone to error. Given the complexity of programs today, it is unlikely that a single developer will understand all of the parts of a large program well enough to do a good job. It is quite easy to optimize one part of a large program at the expense of poor performance in other parts. Accordingly, it is desirable to automate the task of optimizing the ordering of procedures.
A conventional system for optimizing code packing is "Segmentor™, " by Microquill. The Segmentor system employs an iterative process to determine the optimal organization of segments in a Windows program. The process entails creating a database of function calls, updating the database with runtime profile data, and analyzing the data with an optimizer. The database stores segmentation data about which functions calls what. Initially, the database stores static call information, based on source files and link data. Dynamic profile data may later be added to fine-tune the segmentation data. At that time, weights are assigned to function calls, based on data gathered during runtime. Using an optimizer, Segmentor™ searches for an optimal segment layout. The results are then provided to a development system (e.g., in the form of compiler/linker directives or "pragmas" statements). These statements control the placement of functions in segments by the compiler/linker.
Although a good first approach, the code packing optimization method employed by Segmentor is, using presently available equipment, particularly time consuming. Optimizing the code packing of a program of even a modest size may require several hours or more. Given the time pressures of modern-day software development, there is little room in the development schedule for use of such a time-intensive tool. Yet given the potential performance benefits of code packing, there remains great interest in developing optimization techniques which do not incur a substantial time penalty in the development cycle.
The present invention recognizes a need for optimizing the packing of code objects--the procedures, functions, routines, and the like which comprise a computer program--based on analysis of meaningful program activities, such as user-observable tasks. Moreover, the present invention recognizes a need for optimization methodology which does not incur a substantial time penalty in the development of commercial programs.
A preferred embodiment of the present invention comprises a development system having a compiler, a linker, an interface, and an Optimizer. The compiler generates or "compiles" source listings into object modules. In an exemplary embodiment, these are (initially) stored in Object Module Format (OMF) as .OBJ files. These may be linked or combined with other object modules stored in "library" files to create an executable program. The Optimizer embodies activity-based methods for generating a profile bitmap for a program of interest, to find related procedures (based on clustering of activity bit signatures) so that they may be packed together in the final executable program.
A preferred method of the present invention for optimizing the packing of code proceeds as follows. The run (execution) of the program is divided into a plurality of activities, with each activity corresponding to a distinct program activity (e.g., opening a file, closing a file, moving a bitmap, pasting text, and the like). Thus, the program is effectively "sliced" into various activities which are core to the operation of the program. The activities themselves are generally selected to be those which are everyday activities important to the operation of the target program. For a database program, such activities may include, for instance, sorting a database table, printing a report, and the like. For a painting program, on the other hand, such activities may include, for instance, saving a bitmap file, modifying a color palette, cutting/pasting bitmaps, and the like.
Invocation of various code objects or procedures during execution of a given activity is tracked. During invocation of a procedure, program control is transferred to the procedure, the machine code which comprises the procedure is executed. Once the invoked procedure has completed its task, program control is returned back to a point in the program from which the procedure was invoked. Every procedure within the program of interest may be assigned a slot, such as through using debug information; alternatively, system memory may be divided up into small slots (some of which will not correspond to procedures), with marking of those slots which correspond to procedure entry points. Runtime entry into a particular procedure is easily monitored, for example, by hooking to a standard compiler stack-check routine which is invoked during the prolog code of the procedure (i.e., a call to a check routine is made upon runtime entry into the procedure).
A profile bitmap of the program is generated by running (executing) the target program through the various activities. In particular, for each procedure "hit" during an activity a corresponding bit is set in an activity bit set. Thus, each "hit" in the bit set represents that a call has been made to a corresponding procedure of the program, for carrying out the given activity.
Once generation of the profile bitmap has been completed, bit slices may be taken from the bitmap so that a bit signature may be determined for each activity. The bit signature represents a procedure footprint for the activity--an indicator of which procedures were invoked during processing of the particular activity.
The analysis of the resulting data is then inverted as follows. For each procedure, a signature is generated indicating which activities the procedure has participated in. Although the number of unique signatures theoretically possible is quite large (e.g., four billion for tracking 32-bit signature--32 activities), the present invention recognizes that the actual number of distinct signatures generated tends to be far fewer than theoretically possible. Instead, the tendency is towards very few signatures and many repeating signatures (indicating highly correlated procedures). For a large commercial application (e.g., Paradox for Windows or Lotus 1-2-3), the bit signatures are highly correlated, so that there may be as few as fifty different patterns with twelve activities tracked, for instance. Recognizing this, the present invention provides an optimization method which greatly reduces the data set required for optimization analysis.
Analysis of the data set proceeds by ordering the bit signature patterns, for example, in declining count, or by arranging for neighbors to be maximally connected (e.g., applying least distance standard methodology), or by arranging for global maximization of connectivity, or some combination thereof. This process identifies procedures which should be clustered together. Given this order, related procedures may be located in contiguous or near-contiguous pages of the program by ordering them according to the order of their bitmap signatures. The linker receives information (e.g., a procedure order list) from the Optimizer, so that it may emit an executable image with the determined optimized procedure order .
FIG. 1A is a block diagram of a computer system in which the present invention may be embodied.
FIG. 1B is a block diagram of a software system for controlling the operation of the system of FIG. 1A.
FIG. 1C is a block diagram of a development system of the present invention.
FIG. 2A is a block diagram illustrating the process (of the development system of FIG. 1C) for compiling source modules into object code (modules).
FIG. 2B is a block diagram illustrating various dependencies between procedures which may exist (among object modules and/or libraries).
FIG. 2C is a block diagram illustrating typical placement of machine code for procedures in an executable program.
FIG. 3A is a diagram illustrating construction of a profile bitmap for tracking procedure hit rates for a given activity.
FIG. 3B is a diagram illustrating bit "signatures" which may be derived for each activity (from the profile bitmap 300).
FIG. 3C a diagram illustrating a multi-plane profile bitmap, which maintains a hit count for the procedures, for a given activity.
FIG. 3D is a diagram illustrating a hit count signature for each activity (which may be derived from the profile bitmap 360 of FIG. 3C).
FIG. 3E is a diagram illustrating an inverted analysis of the profile bitmap (of FIG. 3A), where an activity signature is determined for each procedure (i.e., an indicator of the activities each particular procedure has participated in). FIG. 3F is a block diagram illustrating clustering of procedures based on distinctive signature patterns of the procedures.
FIG. 4 is a flow chart illustrating a method of the present invention for optimizing the packing of code in executable programs.
FIG. 5 is a block diagram illustrating page layout (in the packed code of an the executable program) of procedures which comprise a particular procedure cluster.
The following description will focus on a preferred embodiment of the present invention which is operative in an environment supporting page-based virtual memory management, such as found in Intel 80×86-compatible systems. Such an environment loads information into system memory from disk in fixed-length blocks or "pages" (generally ranging from 4K, for example, to up to 64K or more). The present invention, however, is not limited to any particular application or any particular environment. Instead, those skilled in the art will find that the system and methods of the present invention may be advantageously applied to a variety of platforms and environments, particularly those where clustering of related procedures is of benefit. Therefore, the description of the exemplary embodiments which follows is for purposes of illustration and not limitation.
General Architecture
A. System Hardware
The present invention may be embodied on a computer system such as the system 100 of FIG. 1A, which includes a central processor 101, a main memory 102, an input/output controller 103, a keyboard 104, a pointing device 105 (e.g., mouse, track ball, pen device, or the like), a display device 106, and a mass storage 107 (e.g., hard disk). Processor 101 includes or is coupled to a cache memory for storing frequently accessed information; cache memory may be an on-chip cache or external cache, as is known in the art. Additional input/output devices, such as a printing device 108, may be provided with the system 100 as desired. As shown, the various components of the system 100 communicate through a system bus 110 or similar architecture.
B. System Software
Illustrated in FIG. 1B, a computer software system 120 is provided for programming the operation of the computer system 100. Software system 120, which is stored in system memory 102 and/or on disk memory 107, includes a kernel or operating system (OS) 121 and a windows shell or interface 123. One or more application programs, such as application programs 125 or windows applications program(s) 127, may be "loaded" (i.e., transferred from storage 107 into memory 102) for execution by the system 100. OS 121 and shell 123, as well as application software 125, 127 include an interface for receiving user commands and data and displaying results and other useful information. Software system 120 also includes a development system 150 of the present invention for developing system and application programs. As shown, the development system 150 includes components which interface with the system 100 through windows shell 123, as well as components which interface directly through OS 121.
In a preferred embodiment, the system 100 includes an IBM-compatible personal computer, available from a variety of vendors (including IBM of Armonk, N.Y.). Operating system 121 is MS-DOS and shell 123 is Microsoft® Windows, both of which are available from Microsoft Corporation of Redmond, Wash. Alternatively, the system 100 may be implemented in other platforms, including Macintosh, UNIX, and the like. Development systems 150 include Borland® C++, available from Borland International of Scotts Valley, Calif. Application software 125, 127, on the other hand, can be any one of a variety of application software, including word processing, database, spreadsheet, text editors, and the like.
C. Development System
Shown in further detail in FIG. 1C, the development system 150 of the present invention includes a compiler 153, a linker 180, and an interface 155. Through the interface, the developer user supplies source modules 161 to the compiler 153. Interface 155 includes both command-line driven 159 and Integrated Development Environment (IDE) 157 interfaces, the former accepting user commands through command-line parameters, the latter providing menuing equivalents thereof. From the source code or listings 161 and headers/includes files 151, the compiler 153 "compiles" or generates object module(s) 163. In turn, linker 180 "links" or combines the object modules 163 with libraries 171 to generate program(s) 165, which may be executed by a target processor (e.g., processor 101 of FIG. 1A). The standard libraries 171 include previously-compiled standard routines, such as graphics, I/O routines, startup code, math libraries and the like. The user developer may designate other libraries (e.g., custom libraries) whose code is to be linked into the target executable.
In a preferred embodiment, the compiler includes Borland® C++compiler. A description of the general operation of development system 150 is provided with Borland® C++, available directly from Borland International. In particular, the reader may consult the following manuals: (1) Borland C++User's Guide, (2) Borland C++Programmer's Guide, and (3) Borland C++Tools and Utilities Guide, all available from Borland International. For additional discussion of the compiler, the reader may consult U.S. patent application Ser. No. 07/894,706, commonly owned by the present assignee. For a general introduction to the construction and operation of compilers, see Fischer et al., Crafting a Compiler with C, Benjamin/Cummings Publishing Company, Inc., 1991. The disclosures of each of the foregoing are hereby incorporated by reference.
A debugging module 181 is provided for tracking and eliminating errors in the programs 165. During compilation of a program, a developer user may specify that the program is to be compiled with "debug info." Debug info is used by the debugger 181 for tracking execution of the debuggee with the corresponding source listings. The general construction and operation of debuggers is well described in the technical, trade, and patent literature. See e.g., Pietrek, M., Writing a Windows Debugger, Windows/DOS Developer's Journal, pp. 6-12, June 1992. Particular user operation of the debugger 181 is described in Borland C++: User Guide, Chapter 6: Using the integrated debugger, Part No. BCP1240WW21770, Borland International, 1993. Formats for debug info are described in the technical literature; see e.g., Borland Languages: Open Architecture Handbook, Part No. 14MN-RCH01-10, Borland International, 1991.
As shown, the system 150 also includes an Optimizer module 183 of the present invention. Before describing the construction and operation of the Optimizer 183, it is helpful to briefly review the relationship between coded procedures (functions or routines) set forth in one's initial source code and executable procedures as they reside in executable code modules. This relationship is perhaps best understood by tracing the genesis of a program from source code listings to object code modules, and then finally to an executable (binary) program image.
Genesis of an Executable Program
A. Object (OBJ) Modules
During creation of a program, individual translator outputs (i.e., outputs from compilers and assemblers) are linked together to create the executable program. The translator outputs or object modules ("OBJs") store a plurality of records describing the object language (e.g., Intel 80×86) used for input and output of object language processors, such as linkers and librarians. The basic layout of an 80×86 OBJ module and its records is defined by the Intel Object Module Format (OMF). The order of the records is to some extent arbitrary.
For a detailed discussion of the Object Module Format standard, including Microsoft's extensions, the reader should consult: (1) 8086 Relocatable Object Module Formats, Intel Corporation, 1981; (2) Microsoft C Developer's Toolkit Reference, Microsoft Corporation, 1990; and (3) The MS-DOS Encyclopedia, Microsoft Press, 1988. The disclosures of each of the foregoing are hereby incorporated by reference.
B. Sample source and object files
The relationship between various source modules and their corresponding object modules is illustrated in FIGS. 2A-B. Source modules 201, 203 illustrate typical source code modules, such as would be supplied to the compiler 153 for generating modules of object code. Each module 201, 203 includes certain symbols which are "external" to the module and others which may be "public" to the module. In source 201, for instance, the routine MY-- PROC-- A is defined in that source module. As such, the routine is available for use globally (i.e., "public" visibility) within the source module 201.
Often, however, it is desirable to invoke routines which may be defined elsewhere (e.g., such as in a library file purchased from a third party vendor). As shown for the MY-- PROC-- A routine, for instance, a DRAWRECTANGLE routine is called. However, the DRAWRECTANGLE routine is defined elsewhere (i.e., the actual steps for the routine are set forth in a different module). Thus, the symbol "DRAWRECTANGLE" is "external" to the source module 201.
As shown by the object modules 211-213, the compiler 153 emits a particular (OMF) record for a symbol, based upon whether it is an external or public reference. As shown for the object module 211, for example, references to DRAWRECTANGLE, DRAWCIRCLE, and MY-- PROC-- D are stored in the object modules as external records. On the other hand, the two routines defined in source module 201--MY-- PROC-- A and MY-- PROC-- B--are stored as public records. The object module which source module 203 compiles into is also shown (as object module 213).
All told, there are dependencies between the various modules which exist. FIG. 2B illustrates dependencies 250 which may exist, for example, for the object modules 211, 213. Source module 201 generates object module 211. The module 211 includes three external references: 1) DRAWRECTANGLE, 2) DRAWCIRCLE, and 3) MY-- PROC-- D. The first two externals are satisfied by a library file 220, which itself is comprised of a plurality of object modules (e.g., object modules 221, 223). As is known in the art, a library essentially comprises a collection of object modules; an exemplary library format is that provided by Microsoft for MS-DOS (see e.g., The MS-DOS Encyclopedia, Microsoft Press, 1988). The third external reference (MY-- PROC-- D) is satisfied by the companion object module 213; that is, the module 213 includes a public record for MY-- PROC-- D which satisfies the corresponding external record for the object module 211. As shown by FIG. 2B, a multitude of interdependencies may exist, all of which must be satisfied during linking to create a valid executable program.
C. Emitting an Executable Image (Linking)
From the object file(s) and library file(s), an executable program may finally be generated. In general operation, a linker, such as linker 180, proceeds to scan the object module files desired to be included in the link operation. The linker also scans the object modules contained in any library files which have been specified to be included in the link. The linker gathers sufficient information to determine requirements for creating the executable, such as memory resources which are required by internal tables for the link operation.
After processing all of the object module files and library files, the linker determines which of the object modules contained in the library files are actually necessary to the link. A module is marked as "needed" if it contains one or more public records (e.g., OMF PUBDEF Records) that have been referenced via an external record (e.g., OMF EXTDEF Record) in another object module. The linker may then proceed to reprocess all of the object modules contained in the object files and any of the object modules contained in the library files but only for those which were marked as "needed." Any object modules in libraries that are not needed are skipped (i.e., not read into memory). As the object modules are processed, the executable image (Program 165 of FIG. 1C) is constructed and emitted.
An executable image layout is illustrated in FIG. C. The binary image includes, among other things, one or more code segments for storing the machine instructions which define the particular procedures of the program. For instance, Code Segment1 (260) includes the machine instructions for MY-- PROC-- A (261), beginning at offset 0000. MY-- PROC-- A is followed by MY-- PROC-- B at offset 1377; it, in turn, is followed by MY-- PROC-- FOO, beginning at offset 5499.
Code Segment1 (260) may be followed by additional code segments, such as Code Segment2 (270). In a manner similar to that described for Code Segments, Code Segment2 comprises machine instructions for a plurality of procedures, such as the DRAWRECTANGLE procedure 271, which begins at offset 0000. Thus as shown by FIG. 2C, the routines from the object modules and/or libraries are ultimately placed in an executable program. It is the relative arrangement of the routines, with respect to one another, which impacts ultimate program performance and is therefore of particular interest to the present invention.
Also shown in FIG. 2C, the program code may be divided into a sequence of "pages" boundaries 275. To understand pages and page boundaries, it is helpful to first review generally how a computer system manages memory resources. In this manner, the methods of the present invention for optimizing placement of procedures within an executable program may be better understood.
Virtual Memory and Program Memory Management
The memory of most computer systems has associated with it a logical memory structure or layout. This is ultimately mapped into a physical memory layout, which is organized as a series of storage units (e.g., bytes). Thus, a software program views memory not in terms of physical memory but as logical memory or "virtual memory."
In order to provide more memory than is physically available, virtual memory does not correspond directly with the physical memory structure. For instance, the number of physical addresses on a particular computer is limited by how much memory the computer has; the number of virtual addresses, on the other hand, is limited only by the number of addresses available in the virtual address space. A system that supports a 32-bit virtual address space, for instance, may provide 232 or 4 gigabytes of virtual memory (despite the fact that the amount of available physical memory is substantially less).
A virtual address space is, therefore, a set of logical memory addresses available for a program to use. Typically, the virtual address space is divided into blocks of equal size called "pages." Likewise, physical memory is divided into blocks called page frames, which are used to hold pages. Thus the virtual address space is divided up into units called pages which are translated or mapped into corresponding units or page frames in the physical memory. Pages and page frames always retain the same size, with a size of 4K being fairly typical for an 80×86-compatible system. Page size for modern operating systems, however, can be quite large (e.g., 64K for Microsoft® Windows NT).
For providing more virtual memory than is available from physical memory, a scheme is required for swapping out pages to a storage device (e.g., device 107 of FIG. 1A). In a typical hardware implementation, virtual pages are tracked in a page table, with each entry in the table having a "present/absent" bit for indicating whether a particular page is mapped or not (i.e., present in physical memory). When a program tries to use an unmapped page, a "page fault" is trapped to the operating system. The operating system fetches the page just referenced into a page frame just freed (according to one of many possible algorithms), changes the map, and restarts the trapped instruction. Thus, using tables called page tables, the linear address undergoes a translation to a physical address.
In some systems, pages may also be provided with additional flags for controlling page protection. For example, a page may be set to read-only which will allow that page to be examined, but not written to. Controlling page-level protection can lead to more reliable programs by ensuring that a process does not accidentally write to pages that should be read-only, such as locations reserved for code. Any time a process attempts to access a memory page which it is not allowed access to, an exception occurs. As a result, execution of the program temporarily ceases while the operating system services the exception.
For a general introduction to virtual memory systems, see Tanenbaum, A., Operating Systems: Design and Implementation, pp. 206-212, 1987. For a comprehensive introduction to memory management services of a multi-tasking operating system, such as Microsoft Windows NT, see Yao, P., An Introduction to Windows NT Memory Management Fundamentals, Microsoft System Journal, pp. 41-49, July--August 1992. The disclosures of the foregoing references are incorporated herein by reference for all purposes.
Optimized Code Packing
A. Introduction
Consider the code arrangement for present-day commercial applications. If one were to run across a spectrum of features in a program, say, Paradox® for Windows or Lotus®1-2-3, one would get a profile of what code is needed for everyday operation of the program. The actual number of procedures touched by such a sweep is typically on the order of about 40% of the total number of procedures. With conventional methodology, however, there is often little correlation between such usage (by the user) and actual placement of procedures in the executable program code. In order to use the approximate 40% of procedures touched in Lotus 1-2-3, for instance, one would have to load nearly every segment and every page in the product--several megabytes, instead of just one or two megabytes.
The example may be simplified by focusing on a single activity in a simple program. Consider, for instance, a program having just ten activities with one of activities--Activity A--using only ten percent of all available procedures. If those procedures required by Activity A are evenly scattered throughout all of the program's code, then for Activity A to run each page of code of the program must be read into system memory. In other words, the entire code set for the program must be read into memory to complete Activity A, despite the fact that Activity A only requires ten percent of that code set.
By grouping or clustering together related procedures (e.g., those for Activity A), however, programs may be made to load faster, change activity more responsively, and run in a smaller memory space. It is therefore highly desirable to optimize the arrangement of procedures within a program in order to minimize, for a given task, the swapping of pages from a storage device. Moreover, for segmented-memory architecture (e.g., Intel 80×86; systems), it is desirable to optimize the arrangement of procedures within a program in order to minimize the number of intersegment or "far" calls (which are computationally more expensive). By optimizing the relative placement of procedures within an executable image, the Optimizer 183 of the present invention provides an efficient mechanism for achieving these goals, thereby improving program performance and conserving system resources.
B. General Operation
The general operation of the Optimizer 183 proceeds as follows. Every procedure within the program of interest is assigned a slot, such as through using debug information. Alternatively, system memory may be divided up into small slots (some of which will not correspond to procedures), with marking of those slots which correspond to procedure entry points. For instance, as procedures tend to be greater than at least 16 bytes, slots of 16-byte boundaries may be employed. Actual determination of which procedure entry points correspond to which slots may be deferred until after a test run (described below), instead of at runtime. The function prolog code emitted by the compiler may be modified so that at the entry of each procedure a call is made to a special handler. This modification is not unlike the present-day approach employed for stack checking by the compiler (where a call to a check routine is made upon entering a function).
Next, the run of the program is divided into a plurality of activity slots. Each slot, in turn, corresponds to a distinct program activity, such as opening a file, dragging an icon around, and the like. More particularly, the activities are those which are everyday activities important to the operation of the program. In other words, an activity profile is created which tracks the various tasks which are core to the operation of the program. For a database program, such activities may include, for instance, sorting a database table, printing a report, and the like. For a painting program, on the other hand, such activities may include, for instance, saving a bitmap file, modifying a color palette, cutting/pasting bitmaps, and the like. Regardless of program type, however, the target program is effectively "sliced" into various activities.
In a preferred embodiment, the number of such activities derived need not be large but may, instead, be on the order of about two to three dozen activities. In a preferred embodiment, one employing Intel 80×86 architecture, the number of activities is set equal to a multiple of the underlying machine word (e.g., 32), for efficient use of machine architecture. Other numbers of bits may be employed, if desired, including for instance 8-bit, 16-bit, 64-bit, and 128-bit quantities. Preferably, the size of the bit set is not set too large. Otherwise, the signature patterns (described below) will tend to have a correspondingly larger number of "noise" bits.
As illustrated in FIG. 3A, after a run of the program a profile bitmap 300 is generated. As shown, for each activity a corresponding bit set is generated. For Activity #1, which may be for instance the task of saving a file to disk, the bit set 310 is generated. Each "hit" in the bit set (i.e., bits in the bit set which have been set to "high" or "1") represents a call made to a corresponding procedure of the program, for carrying out the activity. For Activity #1, for instance, Procedures #2 and #5 are called. By way of example, if Activity #1 represents the task of saving a file, Procedure #2 may be a routine for retrieving a file handle from the operating system and Procedure #5 may be a routine for writing a block of information to disk (for the file handle retrieved by Procedure #2).
As shown in FIG. 3B, bit slices may be taken from the bitmap so that a bit signature may be determined for each activity. This bit signature, in turn, represents a procedure footprint for the activity--an indicator of which procedures were invoked during processing of the activity.
As shown in FIGS. 3C-D, the profile bitmap of the present invention may be modified for tracking a plurality of reference counts. Profile bitmap 360 is a multi-plane bitmap (i.e., there exists more than one bit for each activity/procedure slot in the bitmap). The depth of the multi-plane bitmap 360 may, for instance, be set to 16 bits (24) or 32 bits (25).
In a manner similar to that shown for the profile bitmap 300, an activity slice (e.g., slice 370) may be taken through the bitmap for obtaining a signature for a given activity. Signatures for the various activities of bitmap 360 are shown in FIG. 3D, as signatures 380. Upon reviewing the signatures 380, it is apparent that additional information has been preserved. In particular, an indicator of how dependent a particular activity is on a given procedure may readily be determined. Activity #4, for instance, is heavily dependent on Procedure #5. Activity #5, in contrast, depends on Procedure #5 to a much lesser extent.
Although the multi-plane variant provides additional information, much of the desired profiling information may be obtained from looking at the hit signatures for profile bitmap 300. The reason for this is that the majority of optimization information desired is encoded in the signature. Assigning relative weights to individual bit members of the signature (although it includes additional information) does not alter the basic dependencies which exist between an activity and its requisite procedures.
During recording (testing) of a program run, it is generally preferable to track the bits on a column-wise basis. In particular, as there may be a fairly large set of bits for a given bitmap, it is advantageous to record the procedure hits (or counts) for a given activity and then flush that bit column to a desired destination (e.g., large-capacity storage device). In this manner, a relatively small number of bits (e.g., a single bit column) need only be maintained in system memory at a given time; accordingly, available memory resources are conserved. This is particularly advantageous when one considers that additional memory resources are required for storing the recording procedure which tracks the procedure calls made during operation of a particular activity.
At the conclusion of the reporting, a bitmap has been built up, such as the bitmap 300 of FIG. 3A. The analysis of the results is inverted, as shown in FIG. 3E. For each procedure, a signature is generated indicating which activities the procedure has participated in. In other words, for each procedure a bit pattern is generated which is a signature of N (activities) bits wide, such as 32 bits (as shown for the example of FIG. 3A). As discussed earlier, the number of activities will typically be a small number, such as 16 or 32 (bits), or a similar quantity which fits neatly into machine words (of the underlying architecture).
Given a 32-bit signature--that is, 32 activities to track--one could, in theory, have up to four billion (232) patterns. In other words, it is theoretically possible for every procedure to have a distinctive pattern. The present invention recognizes, however, that the actual number of unique signatures generated tends to be far fewer than theoretically possible. Instead, the tendency is towards very few signatures and many repeating signatures (between procedures), such as clustered signatures 357 illustrated in FIG. 3F. Recognizing this, the present invention provides a substantially more efficient technique for identifying procedures which should be clustered together. In particular, procedures which share a particular signature (pattern) are candidates for clustering together.
C. Code Packing Optimization Method
Referring now to FIG. 4, a method of the present invention for organizing code for close packing is summarized. At step 401, profile information for each procedure is gathered as follows. Entry into the procedure is trapped, for example, by hooking an existing stack-check routine. At step 402, a bitmap is built of one bit per N bytes of code (e.g., N=4); alternatively, one bit is assigned per procedure via debug info. The actual hits are gathered at runtime in a set of "shadow segments." In a preferred embodiment, hit logging may be switched on or off, as desired. When it is switched off, the contents of the (just-recorded) bitmap are written to disk and the bitmap is reinitialized (hits are zeroed) to allow further testing (as described below).
At step 403, the program of interest is run through characteristic (everyday) activities, such as printing a file, copying/pasting text, sorting a database table, and the like. As shown at step 404, between each activity, hit logging is switched off and on again, to write out a separate hit map for each activity. This process is repeated until a broad sample of the target program has been exercised, as shown at step 405.
At step 406, the results are analyzed as follows. The symbols for the program are read in (e.g., from debug information) and then correlated against the hits in the bitmaps. For each symbol, a bitmap signature is built up, where the Nth bit set represents usage for the Nth activity. In typical use, the bitmaps are highly correlated, so that one can easily see that there may be as few as fifty different patterns with twelve activities in a large commercial application (e.g., Paradox for Windows or Lotus 1-2-3). At the conclusion of the step, a list is constructed of all distinct bit patterns.
At step 407, the patterns are ordered in declining count (of how many bits are set), or by arranging for neighbors to be maximally connected, or by arranging for global maximization of connectivity, or some combination thereof. Finally, given the ordering (e.g., ordering shown in FIG. 3F), the procedures may be relocated by arranging them according to the order of their bitmap signatures, as indicated at step 408. The overall process may be particularly automated for 32-bit flat model where moving procedures around causes no near/far problems and results in near optimal packing.
In a most preferred embodiment, clustering is configured at the link stage. In particular, the Optimizer, after it has completed its analysis, generates an ordered list of procedures (via function names), where the order specifies how the procedures are to be placed by the linker into the target executable. There is no requirement that the list be complete (i.e., include all procedures). Any function or procedure omitted from the list may be placed in a conventional way, such as the order in which the linker encounters it in an .OBJ file.
Between the clusters of procedures themselves, a weighting may be assigned to further influence the ultimate packing of procedure clusters. In other words, the activities themselves may be prioritized (e.g., according to importance to the user). This prioritization would then, in turn, be reflected in the final packing of the procedures.
The clustering of procedures allows one to readily identify groups of related procedures so that they may be grouped (in the target executable) so that they are contiguous or nearly contiguous in the page order. The end result of the process is a list of procedures in the order that they are desired to be packed by the linker. The page ordering is arranged so that the working set (set of memory pages) is optimized for the activity at hand. In this manner, procedures for a given task will be arranged as related (neighboring) pages of the program. Therefore, for a particular activity, the working set of pages comprises a cluster of pages storing the related procedures (as determined by their bit signatures). At runtime, increased program performance (speed) may be realized from the resulting smaller working set required for executing a particular task. The smaller working set affords more memory for data and generally leads to less competition between programs for finite system memory. Moreover, a contiguous-page working set helps because when a mass storage device (e.g., device 107) is retrieving the working set from disk, the disk head requires substantially less movement (as it may complete its operation in a single read operation); also, caching and look-ahead techniques (typically, implemented in hardware controllers) will tend to have a much higher success rate.
The present invention ensures that any page loaded into memory contributes a lot to the activity at hand (i.e., many related routines are being loaded). Routines that are infrequently used, on the other hand, are equally clustered somewhere else, so that they may be left on disk until required. This approach is particularly advantageous for operating systems which have substantially large page sizes (e.g., 64K for DEC Alpha operating system).
FIG. 5 illustrates an exemplary code portion 501 from an executable program's packed code 500. As shown, the procedures of procedure cluster 510 (i.e., proc 3, proc 40, proc 44, and proc 45 from Cluster C in FIG. 3F) are packed into contiguous page units 520, thereby allowing the particular activity associated with the cluster to be performed with maximum speed and efficiency. If desired, padding 515 may be (optionally) added between procedure clusters, so that each cluster begins on a page boundary. As previously discussed, the actual size of the pages is not particularly relevant and will generally vary from one hardware/operating system platform to another. What is relevant, however, is that the related procedures are stored in contiguous or near-contiguous page units, so that the efficiency of information retrieval operations (e.g., disk access, caching, and the like) are maximized.
The approach of the present invention, which employs activity-based analysis, is particularly efficient when compared against time slice-based mechanisms. Consider, for instance, a time slice-based analysis of a program comprising 20,000 procedures (a modest number by modern standards). If the test were run for one minute at a sampling rate of ten times per second, a data set of 12,000,000 bits is generated (60 sec×10 times/sec×20,000). For just a single procedure, hundreds of bits are generated. And this is just for one minute's worth of analysis. As such, the time slice-based approach yields an enormous set of data to analyze. Applying conventional analytical methodology, such as "rubber-banding" or least distance analysis, for processing the data set would requires several hours, for even a program of modest size. For large-scale commercial applications, on the other hand, the time required for analysis is not even practical (as such analyses tend to be exponential in nature).
The approach of the present invention, in contrast, greatly simplifies the data set required for analysis by basing the data set on meaningful program activities, instead of time slices which have no particular correlation to operation of the program. Moreover, as time slice-based samples are arbitrary (i.e., not based on any particular task or activity) there generally tends to be little clustering of time-slice bit signatures and, hence, little opportunity for simplifying data sets. The present invention, on the other hand, has a particular advantage of reducing the data set to just a few hundred signatures for a program having ten to twenty thousand procedures. In this manner, a data set which would have required hours or more for analysis and is reduced to one that may be analyzed in fractions of a second. Also, as the present invention takes into account activities that are important to everyday use of the program, better end results are obtained: the result that is really sought by optimization techniques is for the particular activities which comprise a program to run fast.
While the invention is described in some detail with specific reference to a single preferred embodiment and certain alternatives, there is no intent to limit the invention to that particular embodiment or those specific alternatives. For instance, those skilled in the art will appreciate that the teachings of the present invention may be advantageously applied to data objects, in addition to code objects. In particular, a profile of data objects required for a given activity may be obtained by trapping access to the data objects (e.g., using the previously-described memory protection scheme afforded by virtual memory management systems). The data objects may then be clustered based on repeating groups of signatures, as previously described for code objects. Thus, the true scope of the present invention is not limited to any one of the foregoing exemplary embodiments but is instead defined by the following claims.


text: UPR's Extreme firewall adjuster is the most economical and best engineered firewall adjuster ever devised for your 1979-2004 Ford Mustang. Featuring a Locking Set screw design built in to in the adjuster and a Locking nut to give you the choice of locking methods. Extended range of adjustment and larger firewall backing plate to eliminate firewall flex and premature cable wear. Three mounting hole capacity for the ultimate in strength. CNC Machined from 6061 Billet Aluminum with an extra thick base for additional firewall support and two different ways to lock in your setting.

subset: commoncrawl


text:
Garfield 1 and 2 Double Pack DVD|
Titles Comprise:Garfield:It ain't the cat in the hat!Fat feline Garfield (voiced by ever excellent Bill Murray) enjoys his endless days of restful relaxation, lasagne dinners and the undivided attention of his owner Jon (Meyer). However, when Jon attempts to impress the ice-cold vet Liz (Love Hewitt) he takes in the hyperactive abandoned dog Odie. Turning Garfield's world upside down, Odie is promptly dog-napped by evil TV celebrity Happy Chapman (Tobolowsky) and the corpulent cat must brave the outside world to bring him back!Garfield 2:Garfield, America's favourite cat, is going continental. He's travelling across the pond (with canine sidekick Odie) to surprise his master, Jon Arbuckle (Meyer), who is in London to propose to his girlfriend, veterinarian Liz Wilson (Hewitt).In the land of Big Ben, Buckingham Palace, Scotland Yard and fish and chips, Garfield's British invasion takes on a Prince and the Paw-per dimension. He inadvertently switches places with the Prince, a royal cat (and by luck his exact look-a-like), who has just inherited Castle Carlyle from his deceased owner, Lady Eleanor, this is a huge disappointment to her dastardly nephew Lord Dargis (Billy Connelly).Now living it up as the Cat of Carlyle, Garfield has a butler, and an international array of servants and subjects, including Winston, a very English bulldog; McBunny, a Scottish hare; Nigel, a Punjab ferret; Bolere, a Spanish bull; I Claudius, a Shakepeare-quoting mouse and Christophe, a French goose.Meanwhile Prince is living the simple life of a commoner, hitting the pubs with Jon and Oldie, getting his first taste of lasagne...and loving all of it!Uneasy is the head, however, that wears the crown. Lord Bargis, who is next in line to the estate, wants Prince/Garfield out of the picture. Garfield's bigger, better, more pur-fect world is soon turned upside down in the tale of two kitties!from£5.79 | RRP:
* Excludes Voucher Code Discount Also available Used from £2.13
- 17 April 2019
- Peter Hewitt, Tim Hill
- Bill Murray, Breckin Meyer, Jennifer Love Hewitt, Stephen Tobolowsky, Billy Connolly
- 20th Century Fox Home Entertainment
- 158 minutes
Garfield double bill. In 'Garfield - The Movie' (2004), Jon Arbuckle (Breckin Meyer) and his pet cat Garfield (voiced by Bill Murray) live in harmony together - until Jon introduces a new member to the family: Odie the loveable pooch. Jon adores Odie, not least because having two pets means twice as many trips to visit the the vet, Dr Liz Wilson (Jennifer Love Hewitt), with whom he is totally besotted. But Garfield is less keen, and orchestrates a 'dognapping' that he hopes should get rid of his rival once and for all. In the sequel, 'Garfield - A Tale of Two Kitties' (2006), the laziest cat in America swaps places with the richest feline in England. Jon is on his way to London to propose to Liz, and Garfield is determined to be there when Jon pops the big question. Of course, Garfield wouldn't go anywhere without his old pal Odie, and soon after arriving in the land of Big Ben, the clueless tomcat inadvertently changes places with royal lookalike Prince. It seems that Prince's owner, Lady Eleanor, has recently passed away, leaving the care of her sprawling estate Castle Carlyle in the capable paws of her devoted kitty companion. The trouble is, Prince has decided it's time for a vacation, and with Garfield in charge there's no telling what kind of trouble will befall Castle Carlyle.
More DVDs Directed by Peter Hewitt
More DVDs Directed by Tim Hill
More Titles Starring Bill Murray
More Titles Starring Breckin Meyer
More Titles Starring Jennifer Love Hewitt
More Titles Starring Stephen Tobolowsky
More Titles Starring Billy Connolly
Enter a target price.
Enter your review of Garfield 1 and 2 Double Pack [2004]. We will post your review within a day or so as long as it meets our guidelines and terms and conditions. All reviews submitted become the licensed property of www.find-dvd.co.uk as written in our terms and conditions. None of your personal details will be passed on to any other third party.


text:
At Frey, we create compelling, functional design for web & print.
A close-knit group who enjoys creating beautiful, meaningful design for print and web. We believe in working hard and having fun along the way. Whether designing a new visual identity or coding additional functionality for a website, we understand that the easy way isn't necessarily the best. Our team strives to excel in every aspect of design to grow individually and as an agency.
Good design follows ideas, and good ideas are only formed after careful consideration and research. Before creating pixel-perfect designs, we use pen and paper to explore ideas and challenge ourselves to discover something new. During design and development, we bring our concepts to life with excellent craft and consideration. Finally, we ensure that every project is properly executed and delivered correctly and on-time. Our design process has led us to client partnerships that have spanned over twenty years.
Good research is the foundation for good design
Experimentation brings the best concepts forward
Success comes from proper execution of good ideas
As a full-service design agency, we strive to ensure that every piece of collateral is leveraged as a strong brand-building tool. We have a broad range of services to help our clients find their voices and succeed within their industry. Below are some of our core offerings.
We are grateful for every client that has trusted us with their brand and projects. We embrace clients of every industry, size, and location – from individuals in the Chicagoland area to international Fortune 100 companies. We appreciate our new relationships and thank our clients who have been with us for over twenty years.


text:
Griffin directed New Moon for Encores! in Manhattan and Beautiful Thing in Chicago and Off-Broadway. Opening for the Marriott run of the Jerome Kern-Oscar Hammerstein II classic is Oct. 1, following previews. Performances continue to Nov. 30.
The company includes Sean McDermott as Ravenal, Jamie Dawn Gangi as Magnolia, Susan Moniz as Julie, Dale Benson as Capt. Andy, Mary Ann Thebus as Parthy, Michael Gerhart as Frank Schultz, Michele Graff as Ellie May, Derrick Smith as Joe and Felicia Fields as Queenie, with Rachel Alston, Mallory Baysek, Adam Busch, Steve Calzaretta, John Clonts, Dwelvan David, Patrick Gagnon, Christopher Garbrecht, Angela Grovey, Tommy Hahn, Martin Hargrove, Adam Koslowski, Joan Krause, Catherine Lord, Amy Lyn McDonald and Linda Parsons.
Tom Murray is musical director. Marc Robin is choreographer.
For ticket information, call (847) 634-0200 or visit www.marriotttheatre.com.
* Griffin is attached to a developing musical version of The Color Purple.


text:
Woohoo another night of not eating anything after dinner. Also a very successful day saying no to candy and ice cream at work yesterday
DS and DS now have colds, I can feel the back of the throat tickle myself so oil of oregano is my method to try and avert the virus from taking hold.
I will have to keep you all updated on the saga of DS and his push to be allowed to "date" this girl in his class. I still cannot get over this behaviour and last night when I said it was OK to be friends with lots of kids in school but he was too young to have girlfriends, he told me that she was more than a friend and that they had so much in common , "well except for sports".
I meet every other week for coffee with a group of parents of learning disabled kids. One of my friends is an Educational Assistant in public school with 10 - 12 years olds and she said they were recently told that about 30% of the kids they work with have played, or watched Grand Theft Auto. I am only familiar with this title in terms of hearing how violent it is and, of course, totally appropriate for kids. She said she hears them talk about the "death cam" in class and how riled up they get when describing the game. It sounds gruesome and horrible.
We have purposefully sheltered our kids from most TV , reality shows and other questionable content. I feel like the introduction to this school is like a crash course in everything I dislike about how children are treated like mini adults and pushed too early to behaviour that is developmentally wrong.
DS , on the other hand loves it!
And, it has not escaped me that in his desire to have this girl over to show her his house and hobbies, he is upstairs practicing his guitar and cleaning the living room!


text:
In the past week the weather has taken a turn towards much colder temperatures in much of the UK. It isn't snowing – YET! – however a change in temperature means a change in management for our horses and ponies, which can provide a challenge for equine owners, so it is important to be clued up, in order to handle the adjustments to your horse or pony's care that may be forthcoming.
One of the main factors to be borne in mind is your horse's nutritional needs over wintertime. During Autumn and Winter, monitoring your horse's weight is advisable, as it can be of detriment if they loose weight during this time, approaching Winter below par.
It is vital to recognise that during the winter months, our equines' grazing is reduced, or it may even be frozen over on cold days, and this is in addition to the fact it will be depreciated in nutritional value. Therefore it is vital to supply ample hay or haylage both during the day at pasture and whilst your horse is stabled at night.
A weighty issue
Keeping your horse the correct weight and supplied with the necessary nutrients can be a challenge in winter time and it is all too common for equines to loose weight during this time. Essential fibre in the form of hay or haylage keeps the gut healthy and mobile. Also digesting bulky forage helps to keep our horses warm through the fermentation process of the roughage being digested and this helps your horse to stay toasty and the correct weight! This should be provided alongside a correctly balanced concentrate feed when required and a vitamin and mineral supplement such as Scientific Nutritional Products' Horse & Pony Multivitamin Supplement!
An equally critical point is to remember that in cold weather, our water buckets and troughs are susceptible to freezing. Upon reaching the yard this should always be the first thing horse owners check in wintertime, as our horse's water source may have been inaccessible for a period of time if there has been a hard frost over night! It can be wise to add hot water to your horse's water buckets, if it is safe to do, so the night before as this can help prevent the buckets freezing over!
In terms of your horse himself, his mechanism for keeping warm as well as eating plenty, is to grow a woolly coat.
Some horse owners allow their horse's coat to grow in order for their own natural resources in a warm winter coat to support them.
However, if you intend to work your equine hard over the winter season, it may be essential to clip them. Make sure you only apply a full clip if your horse needs one, or if they are simply in light, gentle work, a blanket or trace clip may suffice. If your equine is clipped it is important to ensure they are sufficiently rugged in order to make sure they doesn't lose energy, calories and weight whilst keeping warm. It is advisable to check the weather forecast each morning and night so you can accurately judge what rugs your horse needs!
Visit http://www.horsesupplementsdirect.co.uk for more info on nutritional issues. See our contacts page to contact Peter Fishpool for advice!


text:
2018 Craven, Cinsault, Stellenbosch, South Africa
Red | Drink now | Craven | Code: 58204 | 2018 | South Africa > Stellenbosch | Cinsault | Medium Bodied, Dry | 12.5 % alcohol
Free Specified Date & Standard UK Delivery 3 working days for orders over £200.
See Further Details
Eligible for storage in our Bonded Warehouses, terms and conditions apply. See Further Details
You may also like
The Producer
The 2014 vintage was the first commercial release from dynamic husband-and-wife winemaking team Mick and Jeanine Craven. Mick (an Aussie) and Jeanine (a Stellenbosch native) met during vintage in California in 2007 and have travelled the winemaking world since, finally settling in Jeanine's native Stellenbosch.
"We chose South Africa, as we think there is a lot of potential here to make amazing wines. We live in Stellenbosch and our hearts are here in this town, which is why we only make wines from the Stellenbosch region, as we want to be within a heartbeat of the vines. We want to make wines which are interesting, both stylistically and by varietal, but also wines which have a sense of place and express where they come from. We have isolated particular vineyard sites, for their unique soils and micro-climates, where we work with the growers to ensure that we get the best results from the particular sites. All our wines will come from single vineyards around Stellenbosch. Winemaking is very hands off with minimal additions (if any), native ferments and neutral oak."
The 2014 is the first commercial release of wines from dynamic husband and winemaking team Mick and Jeanine Craven. Mick (an Aussie) and Jeanine (a Saffa) met during vintage in California in 2007 and have travelled the winemaking world since finally settling in Jeanine's native Stellenbosch.
Other wines by this producer:
The Grape
The Region
Stellenbosch is South Africa's best-known wine region, producing a wide variety of wines from leading estates, even though it accounts for less than 20 per cent of the country's total production. Designated wards within the wine region are Jonkershoek Valley, Simonsberg-Stellenbosch, Bottelary, Devon Valley and Papegaaiberg.
At 17,500 hectares, Stellenbosch remains the Cape's most famous and important fine wine district, thanks to its proximity to Cape Town, to the cooling influences of False Bay, its mountainous (ie Helderberg, Simonsberg), granitic topography and its centres of learning such as Elsenburg Agricultural College.
It's notable for the refinement of its Cabernet Sauvignon and Chardonnay, especially from the likes of Glenelly Estate, Keermont Vineyards Oldenburg Vineyards, Raats Family and Anwilka
UK Wide
Standard: Within 3 working days (for orders placed before 2pm)
Specified Date*: 9am-5pm
* "Specified Date" is not available in Northern Ireland, The Isle of Man, The Isle of Wight, The Isles of Scilly and some areas of Scotland.
Further Details
**Qualifying order value excludes tickets, vouchers and wines bought inbond
Order value per delivery address**:
Over £200 - FREE DELIVERY
Below £200 - £10.00
Premium Services
Premium Services are available in mainland UK only
Next Weekday or Saturday Delivery
Pre-10am Any Day (not available on Saturday)
Shop Collection
When selecting "Collection" at the check-out, please allow 3 working days for us to process your order from our central warehouses. We therefore highly recommend telephoning before you make your journey to check that your order is ready. Collection is available from our two shops in London & Basingstoke.
International Delivery to Europe & Rest of the World
Subject to a minimum order value of £200 excluding the delivery charge, per delivery address.
Please note: We are unable to deliver Spirits to the USA
All orders for delivery outside the EU may be liable to local duties and taxes for which customers are responsible. The local delivery agent in your destination country will contact you to arrange payment of these taxes
|Wines bought from Berry Bros. & Rudd can be stored
in our temperature controlled warehouses.
We can only accept orders for unmixed cases.
|Storage Charges:
£13.80 (inc. VAT)
per case per annum
|Customer Reserves
|For wines purchased In Bond,
Duty & VAT charges become payable upon withdrawing from your reserves.
BBX wines can only be bought In Bond.
Minimum annual storage charge applies.
More information on wine storage
|£12.60 (inc. VAT)
per case per annum
for Cellar Plan Members


text:
Dr. Polga has over 15 years of experience as a hospital-based Internist, starting in New England and then ultimately here at Baptist Health South Florida (where he served as Medical Director and Head of Inpatient Medicine.) Dr. Polga wished to practice preventative medicine in an environment that would allow for superior medical care, and concierge medicine fit that need.
Dr. Polga is a member of the American Medical Association, and is a graduate of both the Hospital Medicine Leadership Academy and the Building Collaborative Leadership Program. He serves as a Clinical Associate Professor at the FIU Herbert Wertheim College of Medicine.
Dr. Polga is a board-certified Internist. After graduating magna cum laude from the University of Pennsylvania, Dr. Polga pursued his MD from Tufts University, and completed his residency training at the University of Miami/Jackson Memorial Hospital.
Dr. Polga also believes that you should give back to the community with which you serve. He thus sits on the Baptist Foundation Advisory Board, Coral Gables Community Foundation Board, is active with University of Miami Citizens Board, Coral Gables & Key iscayne Chamber of Commerce(s), ChamberSOUTH, Village(s) of Key Biscayne & Pinecrest, Camillus House, British American Business Council, Kiwanis International, Key Biscayne ions Club & Rotary Club, Gulliver Schools, and holds privileges at Baptist Hospital, South Miami Hospital, and Doctors Hospital.
Dr. Polga serves his patients with offices conveniently located on Key Biscayne and South Dade with the ability to care for the communities in Brickell, Coconut Grove, Coral Gables, Kendall, Pinecrest, South Miami, Midtown, Miami Beach, and sees international patients as well.
- University of Pennsylvania, College of Arts and Sciences - B.A., Magna Cum Laude, Economics
- Tufts University, School of Medicine - M.D.
- Residency in Internal Medicine at the University of Miami Jackson Memorial Hospital
American College of Physicians Member
Society of Hospital Medicine Member
American Medical Association Member
Federal Emergency Management Agency (FEMA) On-Call Physician
Florida Medical License
Connecticut Medical License
International Thought Leader in Internal Medicine
Diplomate, American Board of Internal Medicine


text:
Your shopping cart is currently empty
Inspired by all things cosmic, the Skylar Layered Necklace features an open-frame pendant with colored gemstones, subtly fashioned after a crescent moon. A petite crystal-studded star hangs on a tiered chain for added shine. Basically, a layered look on-the-go.
Shifting our focus onto all-star pieces embedded with bold colored stones of various shapes, shades and sizes, the Electric Dream collection Is all about high shine and sparkles found in cosmic objects. Unapologetic and authentic like our muse, with lightning in her soul and thunder in her heart.


text:
Website SearchBI
An international software company
QlikView / SQL Consultant– London – Salary up to £50,000
SearchBI is currently working with an international software company who are looking for a Qlikview Consultant with a strong Knowledge of SQL to join their team.
You will participate in exciting projects in London and join a dedicated QlikView team.
Key responsibilities:
- Designing & implementing Qlikview application to clients
- Liaising with end users stakeholders to gather requirements and building applications
- Developing & testing QlikView applications
- Training and support end user with QlikView
- Minimum of 2 years experiences with QlikView
- Minimum of 2 years experiences with SQL
- Ideally, you have experience of working in a Consulting company, editor or certified partner
- Excellent communication skills
This is a permanent position and the salary range is between £35,000 and £50,000 (- Depending on experiences).
To apply for this role you must have full eligibility to live and work in the UK.
For more information on this position and other Business Intelligence roles please visit our website www.searchbi.co.uk
SearchBI are the first choice for Business Intelligence and Agile BI recruitment business in the UK and internationally. We work with Software Houses, Partners and End Users throughout the UK and Europe. As unique specialists in this niche marketplace we have positioned ourselves ideally to satisfy the needs of a variety of clients. We understand our industry and use our expansive network to position ourselves as market leaders for all Agile Business Intelligence requirements.
QlikView / SQL / Qlik Sense / Business Intelligence / Developer / Programmer / Analyst / London / Greater London /


text:
Sergi Fernández Herrera
Academic career
Course of studies in industrial design at Elisava Design University in Barcelona 1997
Bachelor of Arts with a major in design, Southampton 1997
Master's degree in 3D animation
ESI Design School, Barcelona 1999 and 2000
postgraduate studies in production engineering
Fundación CIM (Barcelona University) 2007 and 2008
Qualification as industrial designer at the Elisava Design University; followed by a final training in the Benedito Design Studio. Founded the company ba, Barcelona arquitectura in 2000, since then development of projects in the areas of product design and engineering. Currently collaborating with numerous companies of international rank as a consultant and person responsible for design and production.
Realisation of projects from the most varied areas during study period: technology, furniture, lighting, fashion, graphic art, playground equipment, town planning, interior architecture and temporary architecture.
Project management: street furniture for Expo 2008 in Zaragoza, design of playgrounds for the Universal Forum of Cultures 2004, furnishing the railway station of the Spanish high-speed trains AVE.
C/Muntaner 121, Sobreàtic 1ay2a
08036 Barcelona
Tel.: 0034-(0)934530174 / 0034-(0)629064882
web: www.baarquitectura.com


text:
Walking Stick U Shape Per Pc
No reviews
• Durable and light weight with height adjusting facility
• The soft handles provides for a firm grip for the seniors who need support.
We Also Recommend
Sold Out
Folding Cane - (2352) - T-Shape Wood Handle
Regular price Rs. 1,008.00 Rs. 1,008.00
No reviews


text:
Destiny: The Taken King - Legendary Edition is perfect for new and existing Guardians that are ready to jump into the Destiny universe or continue to carve their legend in the stars. The Legendary Edition features the complete Destiny experience including The Taken King, the next evolution in the Destiny universe, Destiny, Expansion I: The Dark Below and Expansion II: House of Wolves. Unite with 20 million Guardians in the fight to defeat Earth's enemies, reclaim all that we have lost, and Become Legend.
- Powerful New Abilities: To battle back the Darkness and the Taken army, players will get brand new subclasses with new supers. Warlocks will now harness the power of an electric storm, Hunters will carve a bow formed from gravitational void energy, and Titans will summon a flaming hammer that can sear their adversaries from a range or deliver a devastating melee impact.
- New Campaign: A massive Hive Dreadnaught ship looms in the rings of Saturn. Oryx, The Taken King has arrived in our solar system, bringing with him a corrupted army to exact revenge on the Guardians who destroyed his son Crota, and to consume our worlds. Arm yourself with newfound abilities, weapons, and gear. Defeat the Taken hordes. Make your way aboard the Dreadnaught, and face Oryx himself within his inner sanctum.
- New Locations: The amazing Destiny universe continues to expand - Infiltrate a Cabal base on Phobos, and establish a beachhead on Oryx's flagship - the Dreadnaught - a mysterious, loot-filled fortress. Charge into the Crucible where all-new competitive multiplayer maps await you and your Fireteam.
- Level Cap Increased and All-New Gear: Fill your arsenal with brand new weapons and armor. Find and collect new, powerful Exotics while continuing to level up in the Destiny universe.
- New Activities: Adventure through new Strikes featuring powerful bosses, follow more questlines that lead to powerful, new gear and brave the next major Raid to test six-player Fireteams.
|Order Total (RM)
|Delivery Fee (RM)
|Flat Rate
We will provide you with the tracking number via email once we send out your package so that you can track it while it is in transit.
The lead shipping time to West Malaysia is approximately 3 to 4 working days after dispatch. An additional day is required for deliveries to East Malaysia.
You will be happy to know that delivery is free of charge throughout Malaysia!


text:
What a fantastic response you have provided in offering guitars and guitar strings. I have enough to take not only this time, but also next time when ministering in the Pacific on behalf of Anglican Missions.
It was while I was in Papua New Guinea watching various music teams practice for Sunday services that I realised just how important guitars are for them. The churches don't have organs or pianos! Music is lead entirely on guitar - or nothing. Having replacement strings is vital and in the villages they are as rare as hens teeth! I could not buy a set in Port Moresby; yes the shop sold guitars but not strings! I hope it is easier in Samoa and American Samoa.
Thank you all for your wonderful responses.
Rev Mike Hawke


text:
For the complete article with video, click here.
Saturday, March 2, 2013
By Bill firstname.lastname@example.com@bdebusnh
Auburn Career Center Superintendent Maggie Lynch must have taken a lesson from some of the school's practical nursing students.That's because an important part of Lynch's job is regularly checking the pulse of the region's labor market.For example, Lynch and other Auburn officials recently met with polymer manufacturers from the region to discuss their workplace training needs and if the school could provide assistance."We're always trying to seek that rhythm of the relationship between the work force and what our role can be to prepare workers and students that would fill the many levels of jobs, from entry level to higher level jobs," she said.Located at 8140 Auburn Road in Concord Township, Auburn Career Center provides career and technical education to both high school students and adults.While adult learners fill the classrooms and laboratories at Auburn during the evening hours, two shifts of high school students — juniors in the morning and seniors in the afternoon — complete two-year programs throughout the day."Our goal is to have our courses feed into our current workplace market," Lynch said.As a result, Auburn offers a heavy concentration of programs in manufacturing, the automotive trade, information technology and allied health, she said.For several of those programs, Auburn has made impressive upgrades in equipment and facilities.Auburn recently spent $1.5 million to redesign its welding laboratory, which includes 20 new welding booths."This whole lab has been completely redone with the best equipment that's available on the market," said welding instructor Steve Waltenbaugh. "The lab has a top-of-the-line vacuum system, machines capable of doing four different types of welding processes ... and every student has all the equipment they need."The versatility of the machines and equipment in the redesigned lab will help Auburn welding students build strong credentials for the job market, Lynch said."That flexibility of being able to go ahead and weld in so many different forms on so many different types of metals is a huge advantage for the workplace," she said.Meanwhile, Auburn also has enhanced its advanced manufacturing training laboratory with the addition of 14 training simulators for Computer Numerical Control machines.The simulators make it possible for more students at a time to become proficient before taking a turn on one of the four full-size CNC machines in the lab.Students can create, simulate and troubleshoot CNC programs on the simulators, said Terry Colescott, high school advanced manufacturing instructor."Once you're happy with the program, you copy it to a USB jump drive, walk over to the machine and plug it in, call up our program off of the jump drive, and it'll run that part on our machine," Colescott explained.The CNC simulators have proven to be an effective teaching tool, Lynch said."It gives everyone a larger sense of experience that students wouldn't have had if they had to rotate and take turns because it was just a single piece of equipment," Lynch said."So this way everyone is learning at a faster and more experiential rate, becoming troubleshooters while they're becoming programmers, which gives them, of course, a greater value to market to the companies (for future employment)."Sometime next fall, the advanced manufacturing classes and several other programs will be moving to a different section of the Auburn campus, as the school is planning to build a $1.2 million industrial arts facility.Plans call for the 15,000-square-foot unattached, prefabricated steel building to be located on the south side of the career center property, toward Girdled Road.The building would house the advanced manufacturing; heating, ventilation and air conditioning; industrial electricity; and facilities maintenance programs."We would like to complete the building hopefully by September so when the students arrive they can move out of the one lab and into the new lab," Lynch said.Auburn Career Center currently enrolls about 700 high school juniors and seniors who choose from 22 different programs.While future enrollment growth is limited because of safety restrictions regarding class sizes, Auburn is working to keep its programs filled to capacity for years to come.It's doing this with several programs aimed at introducing junior high school students to programs offered at the career center.In fact, Auburn conducts career development classes for seventh- and eighth-graders at all 11 school districts served by the career center: Kirtland, Painesville, Riverside, Perry, Madison, Fairport Harbor, Chardon, Kenston, Newbury, Cardinal and Berkshire.Seventh-graders complete a career interest survey during the first semester of the program. In the second semester, all students travel to the career center's Quest Lab at Fairport Harding High School, where they get to perform some hands-on activities in their top three areas of interest, based on results of the career survey.For example, students who show a liking for automotive technology can take off the fenders and doors of a car that's parked in the Quest Lab, Lynch said.In eighth grade, the career development program brings in guest speakers from various fields and each student does a special project on one of the careers.Auburn also provides the parents of eighth-graders with vocational assessments, noting their child's strengths and aptitudes, to offer guidance on choosing the right college or career preparatory courses for grades nine through 12."So for Auburn, in this world of college and career readiness, we have to be of as much service as possible to parents, students and K-12 districts, because we're here as a resource for all of them as well," Lynch said.
© 2013 news-herald.com, a Journal Register Property


text:
Southwest Trail Use Area
The Southwest Area will have a shared trail system for non-motorized trails located on the southwest edges of the Cline Buttes Recreation Area along Innes Market and Fryrear Roads. Most of this area is part of the Peck's Milkvetch Area of Critical Environmental Concern (ACEC), designated in 2005 to protect and maintain populations of this rare plant species.
- 34 miles of Shared Use Trails for hikers, mountain bikers, and horseback riding
Visitors to this area will find themselves in a generally flat sagebrush steppe and juniper woodland area, dotted with basalt escarpments and several high points that offer scenic views. The relic Columbia Southern irrigation canal system winds through the southern portion of this area. The most notable landscape features in the area are several dry canyons located east of Fryrear Road that have many wildlife viewing possibilities. These canyons have prominent basalt outcrops and walls, and support a diverse plant community that includes Indian ricegrass and mountain mahogany, as well as scattered large ponderosa pine trees. Highway 126 traverses Deep Canyon, located to the north of this area.
Trail Use
The Southwest Area is managed for non-motorized trail use, with hikers, equestrians and mountain bikes sharing most trail routes. Most trails will be maintained and designed for horse use, though hikers and mountain bikes can use them; care should be taken to avoid user conflicts. Many of the trail routes are existing roads, although some new trails are proposed, particularly on hilltops that offer scenic views of the Cascade Mountains.
- The Southwest Area is a great example of how public and private lands can intermix; staying on designated trails and limiting your travel to approved trail uses is part of being a good neighbor.
- The Southwest Area is also part of an area managed to protect a listed plant species (Peck's milkvetch); staying on designated trails can help protect this rare natural resource.
- There is a seasonal closure to all uses in a portion of this area, to protect raptor nest areas.
Fryrear Canyon and the southern portion of Dry Canyon are closed to all OHV use, but available for non-motorized use. OHV use is also not allowed west of Barr Road for approximately 1 mile north of Gerking Market Road (an existing east-west grazing fence is the boundary between the motorized and non-motorized trail use areas).
Resources of Interest
When visiting the Southwest Area, take the time to notice some of the amazing natural resources and views around you. Follow the links below for descriptions of these resources of interest.
Peck's Milkvetch
Birds of Prey
Fractured Land Patterns
Know Before You Go
- The Southwest Trail Use Area has many private land inholdings. Please respect private property boundaries, fences and gates.
- Be aware and alert. The area is managed for non-motorized, shared trail use. This requires that trail users keep an eye out for other trail users and share trails. Please follow trail right-of-way rules and give the right-of-way to horseback riders.
- Staying on designated trails to avoid impacts to sensitive plant species found in the area and follow seasonal trail closure orders to minimize impacts to nesting birds of prey.
- For more information on trail use and safety, please visit the Etiquette page.
Access and Directions are available here.


text:
NEW: It Looks Sad. – 'Radical'
First of all big thanks to Pitchfork for pointing us in the direction of It Looks Sad. They are a new(ish) band out of Charlotte, North Carolina who are preparing for the release of their debut 7" later in the summer.
The first (and only) track we've listened by from them so far is 'Radical' and it's a dark affair with lyrics like "I ask why… Do we die?" Though lyrics may be dark, the track is actually a melodious-gem with attractive easy-on-the-ear chord changes which gradually dissipate has the track builds in intensity towards its mouth-frothing finale.
We can't wait to hear more It Looks Sad. For more info on them check out their Facebook page.
'Radical' is taken from the upcoming It Looks Sad. Debut "Self-Titled" 7″ due out in Summer 2014 on Tiny Engines.


text:
Framed or unframed, desk size to sofa size, printed by us in Arizona and Alabama since 2007. Explore now.
Shorpy is funded by you. Help by purchasing a print or contributing. Learn more.
September 1942. Rochester, New York. "Earl and Howard Babcock looking over one of the model airplanes which Howard built." The boys seems to have migrated from the bedroom to the basement. Photo by Ralph Amdursky. View full size.
I can report instances where kids will drop their handheld crap to see what rare and fascinating thing a grandpa type is doing with the plastic contents of a small cardboard box and a tube of clear glue. And it will be interesting to see if this glue-less generation becomes less demented than we are destined to be, ourselves, to follow OTY's line of thinking.
Is that a tube of that nice oh-so-smelly Duco Cement there on the bench?
I don't think kids are interested in model building any more. Don't know why this hobby died. As a kid, I was always building models in plastic or wood. I used to get so much enjoyment from it. I wonder why model building is no longer of interest to kids? It seemed to be fundamental pleasure to me. Maybe that is one reason why we produce so few engineers, designers and inventors these days. Instead of inventing "things", we create social media apps.
Note the Exposition Lemons crate on the workbench with a nice if mutilated example of crate label art:
The one standing on its tail looks to be a Corsair. It definitely has bent wings and given the era is probably not a Stuka.
I think the 50s monogram kits (I built at least the Spad, Piper Cub and Ercoupe) had solid balsa fuselage sides and wings, which needed added balsa stringers glued in, and a plastic cowl and rubber-band propellor. The solid parts made it kid-possible, in that twisting wasn't so much of a bad development.
It still got paper covering on the fuselage top and bottom, and wing bottom. That was shrunk to fit with a little moisture, and then painted with dope (which was actual aircraft nitrate dope, by the way, though it wasn't used for shrinking).
The earlier all-stick airplane models would be a challenge for a kid unassisted, or even an adult.
They didn't fly worth a damn.
I later discovered that you can make fabulously realistic flying models with 4x6 index cards and a stapler. Realistic flying, I mean. Not realistic looking.
Think that's how it was spelled ---wonderful stick kits by Monogram. This picture could have been me, just change it to 1953.
Building these models was no picnic for an amatuer and usually Dad needed to get involved. Then if you crashed it fooling around, you had to start all over again so it may have taught us infinite patience. I also wonder if the medley of fumes from the airplane glue, banana oil and dope (paint) contributed to our eventual senility. Good times.
Howard looks as proud and pleased as can be. When I was about his age, every time I came by a buck it meant a speedy trip to Garman's Hobby Shop (long gone) to buy another "stick model." I didn't have the luxury of a Xacto knife set, so used single edged razor blades for cutting. Assembling the airframe, wings, etc. was relatively easy. The challenge was keeping the tissue paper skin stretched tightly while gluing it, especially on a round shaped frame. A generous application of banana oil normally took care of any wrinkles. Then it was a coat or two of "Dope" model paint before hanging the project from my room ceiling with the rest of the fleet.
Definitely a staged photo. You DO NOT let your little brother anywhere near your model airplanes!
now can we get back to our texting, this is boring.
Notice the handy first aid kit, probably a wise precaution since instruments like Xacto knives were normally associated with the construction of balsa and tissue kits such as these.