WWDC2003 Session 304

Transcript

Kind: captions
Language: en
as you probably all know we jammed a new
GCC 33 compiler this week at the show
and today what I would like to do is
introduce you to that compiler answer
any questions you may have that are
preventing you from moving forward and i
encourage you to move to 3 dot 3 also i
want to introduce you to one of our
partners from IDM we work very closely
in terms of delivering the three dots
three compiler particularly focused on
the g5 and the new g5 system and also
leave you with some idea of future
directions for us so we had a challenge
in putting together three dot 3 compiler
we wanted to deliver a very robust
compiler because we know that's what you
expect we wanted to address compile
speed we've heard very much from you in
terms of compile speed and comparing us
against the code warrior compiler and
also in terms of code quality because we
were introducing a brand new system this
week ajith I system and and we needed to
have terrific optimizations for that
system coming out of the shoot well
that's a very hard problem I've worked
in the compiler area for quite a number
of years and usually you get to pick two
of those three and you can deliver
either a robot's compiler with a lot of
great code quality or you can deliver a
robust compiler that's really fast but
to to try and deliver a compiler that
meets all three of those goals is a real
challenge so I want to talk a little bit
about why we were able to accomplish
that challenge and I think you'll see
that when you install and use GCC three
dot 3 first of all as you know it's
based on the GCC the Free Software
Foundation technology and and today that
technology is is very
mature and stable and continuing to
evolve primarily from the the advent of
Linux systems and lenox system vendors
putting together compiler production
release compilers since that time the
GCC compiler has really matured
significantly their billions of lines of
code that have been put through it we
build our own mac OS 10 operating system
with GCC compiler we have very sensitive
test Suites something on the order of
30,000 tests a day and growing all the
time so so just a very robust experience
and I want to assure you that when you
install the three dots recompiling or
see the same thing one example is one of
our early seeds for three dot three was
one of you folks with an application
about 26 million lines of C++ code that
entire application was my grades at 33
with essentially no problems so what
does Apple contribute because we also
have been putting a big effort in and
and I want to tell you that we're a very
active member of the of the free
software community we have experienced
engineers on staff that have worked in
that community for quite a while we're
an active maintainer the Free Software
Foundation is actually recognized some
of our efforts and they have made Darwin
a reference platform for GCC releases
something that is really fantastic new
optimizations as i mentioned g5 was
really important to us for this release
this system as you've probably seen and
some other presentations is an order of
magnitude more complex to deal with than
the g4 and our mission part of our
mission is to make that happen for you
so that you don't have to do all the
work of extracting the power from g5 so
we've done quite a bit of optimization
you'll hear some about that today you'll
hear some from our partner IDM who
worked with us on that as I mentioned
compilation speeds important and so we
made that a high priority within our
organization and i will show you some of
the performance improvements in terms of
consolation speed and finally just
general maintenance our customers report
problems we fix them we put them into
the community and so we're we're very
active and and correct members if you
will of the community so let me get into
talking about the three things that we
focused on for this release besides
robustness in the language feature area
as you know GCC is already very
compliant with the iso and ansi
standards and so it's it's mature in
that way but it's not a hundred percent
compliant and so it continues to grow
and in this release you'll see some of
that particularly with respect to now
being able to identify incorrect code
that may have slipped by an earlier
releases of the compiler we've also
added a feature in Panther wide
character support a missing feature now
as you know within our own frameworks
and within Apple we encourage you to use
Unicode which is a much more powerful
means of dealing with wide characters
but we have heard your desire to have
applications easier more easily ported
into our environment and in some cases
that requires white characters so that
will be there with the Panther release
you will not have it with Jaguar
objective-c and objective c plus plus
of course we maintain and we we do
enhancement and dissing and one of the
problems that you've told us about is
that we did not have an in section model
particularly for objective-c and so
we've added that that that's also
available in conjunction with the
Panther OS release and finally and I
know you've heard some of these things
in other other forums but finally we've
added another migration tool for you
which is the ability to use inline
assembly or port inline assembly from
the code warrior so completely
compatible with codewarrior other than
bugs you may find since it's a brand new
feature but I think it's pretty robust
we poured it quite a bit of code with it
so compatibilities want from released to
release is always a concern in an issue
the main thing I'd like to point out to
you is what you see here is a very short
list of issues to deal with so so we're
compatible in many many ways one of the
things that you will want to do though
is that you will want to rebuild your
C++ apps a necessity and in terms of
making some enhancements the C++ we've
had an IV and ABI change and so you
simply just need to recompile all of
your your C++ apps in 33 as you know
we've been struggling with precompiled
headers over the years in terms of
providing a complete solution compliant
providing a very robust solution and
we've had CPP pre comp as an early
version of that number of years served
as well but had limitations and we
introduced this time last year PFE and
PFE brought to you and tie
our language coverage which we didn't
have in cpp precum PCH is the next
generation of of essentially PFE more
robust faster implementation and across
all languages and this is a feature that
is going back into the three sulphur
foundation in and will be in other
vendors releases of compilers in the
future the other thing that we have done
within GCC 3 dot 3 is that and looking
at the migration of some code people
were getting tripped up a little bit
with the flags we had certain flags that
you use for cpp pre comp we have some
others for PFE and now we have PCH flags
and so if you were in your development
environment getting those flags
corrected was recognizing that you
needed correct and even was a problem is
so we've made the use of invalid flags
for the particular compiler you're using
a warning so so you'll get a heads up if
you see warnings from compiler flags now
that you hadn't seen before you should
deal with those they're really there to
try and help you out one of the things
that that we get as a result of
defecating CPP pre-comp is that CPP
pre-comp was built on a preprocessor
model which was K in our base and so you
had to flip some switches within the
compiler if you wanted to actually use
the ansi standard c preprocessor now
that we no longer have that encumbrance
we have made the default CPP pre comp
CPP preprocessor the ansi standard
preprocessor it aligns us with all other
GCC compilers that are
being delivered today and finally one
other flag that I would just warn you
about because we've seen some some
resulting difficulty with this as well
is the no standard include flag was
originally intended to not look in any
system directories we found that we
actually had a problem with the
implementation in the 3-1 compiler and
it in fact was looking and finding
header files in in a system directory
well that's correct it now and so if in
fact you were taking advantage of the
fact that certain system directories
were being searched then you'll need to
deal with that as well compile speed
really big deal we begin focusing on
this about a year ago and we had an
offering and I'll show you some
performance numbers we had an offering
in December timeframe where we made
improvements we continue to improve this
we have set our goals very high in terms
of being able to provide speedy
compilation and so let me talk a little
bit about that what we've done to do
that most of you if not all are familiar
with precompiled headers if you are just
bear with me a little bit because we
find that not all of our customers are
using them and and they really are
beneficial and so to make use of and so
the picture that you see here is simply
a representation of a pre-compiled
header and the way that gets created is
that you can create that with the
compiler end and what happens is the
head of Polish precompiled and it's
saved in an intermediate form for the
compiler then when you begin to compile
your own program where you make
reference to
a header that is pre-compiled the
compiler is able to restore that state
and continue the compilation process
this makes the assumption that header
files are a significant portion of your
actual compilation process and that's
certainly true if you're using large
frameworks like carbon or cocoa or app
kit or others like that so so your code
is typically a very small portion of
what is actually compiled when you're
building files like that to make the
best use of precompiled headers it works
best if you can actually identify a
common set of headers that are used by
all of the files that you that you're
building in a prime in a project what
you can do with that is that you can
create a prefix header as we call it
which is a pre-compiled header that
contains those common header files then
you simply include that prefix letter in
your file that you're building and the
compiler breeze will restore a
significant amount of state bypass all
of that compilation process and move
straight into compiling the rest of the
code the next feature is predictive
compilation and and I know that that's
been talked about a little bit in the
Xcode discussions I have a picture maybe
that will help you understand in
predictive compilation where once again
are making the assumption that the
header files are a big portion of your
compilation process and furthermore if
you're going to modify a header you do
that in the context of modifying that
header file not the source file you're
you're editing and so what happens with
predictive compilation is that when you
begin editing a file the compiler in the
background begins the compilation
process on the header files and it will
proceed up into the point where your
code
the code that you're working on then
once you save that code the compiler
proceeds on and predictably compiles
that file for you you can see in the
timeline that I provided here a
representation of that the final feature
and all of these by the way I'm
mentioning even though they are driven
by X code required modification to the
compiler to be able to work
synergistically with Xcode to be able to
provide these compilation features and
distributed compilation the Xcode is
able to actually distribute your
compiles out to other machines that have
been so designated as to be available
for that processing for you and so it'll
make maximum use it sends over the
source file it sends over header files
that you may need so there's no setting
up the environment especially on the
different machines the only requirement
is that you're running the same
generation of OS and so if you're doing
this on Panther you you'll be sharing
all Panther machines but this is a way
that can really speed up your
performance as well so let me let me
just show you the result of this if you
look at this chart as I mentioned over
on the left and Jaguar time frame we
introduced PFE and that was our first
language wide performance enhancement
the application by the way here that I'm
showing the data from is what I would
call a moderately sized C++ app it's
about 250,000 lines of C++ code its
carbon based and it has over a thousand
files the middle point which we offered
in December toolset primarily was the
addition of being able to use the dual
processor on your tower so that using
both processors we were
able to significantly reduce the amount
of compile time still had PFP though
with the introduction this week GCC
three dot zero and Xcode PCH is the new
capability and you'll see on the chart
there the performance over and above TFE
were able to obtain with PCH I wanted to
draw your attention though to one other
point on there and that's the the green
one down at the bottom that says
distributed build this is the result of
building this application with 6x serves
dual processor exurbs 6 because we had
them available actually don't know that
this app required the use of all six but
but essentially you have a means now of
adding horsepower to to get faster
performance even above dual processor so
code quality and I mentioned that we had
a big focus on code quality particularly
with respect to the g5 processor when
you're in the process of trying to focus
on code quality within compilers the
probably the most important tool you can
have is is a real benchmark and that's a
benchmark that that is then a harness so
it's easy to run it provides
reproducible results it represents
applications similar to what you deal
with and prior to g5 we'd use an
internal benchmark that was called skid
marks and skid marks was composed of
kernels of codes from various
applications that we felt were important
in Apple when we reach 25 though we had
a problem and a problem was that not
only were the
files small enough to fit into cash so
that they didn't really represent true
applications on the system but also they
weren't self-checking such that if we
broken optimization that the code might
still run in producing correct results
we didn't have an idea of that we just
knew how fast it ran so we looked around
in the industry and and we chose the
spec benchmark and there are pluses and
minuses with the spectrum inch mark you
can argue as to whether their
representative of Macintosh applications
or not but but we determined that they
were they were close enough that we can
make some good progress animal by the
way we also needed to produce some spec
numbers for this new processor so spec
is represents 12 integer benchmarks 14
floating-point benchmarks they're real
applications that have been encapsulated
into the the test bench and they run in
a harness and they're they're
predictable and validate their results
so let me just show you the the results
of GTI performance with respect
benchmarks and what I'm comparing here
is our 31 compiler versus our 33
compiler today so the compiler you're
using today versus the one that
hopefully you'll be using later on this
afternoon you can see from spec int and
this is an aggregate across the 12
benchmarks in second that we actually
have a 17-percent performance increase
over what we're able to extract from the
three dot one compiler correspondingly
for floating point and this is a
floating point machine as
has been noted in almost every
presentation and floating point we're
able to get thirty percent better
performance than we can with the three
dot one compiler on a g5 and this is a
single processor g5 two gigahertz so
what does this mean for you in terms of
how can you take advantage in and build
your code for the g5 and get performance
well there are several situations that
you may be dealing with first of all you
you may have an app that you want to run
on more systems than just the g5 you may
want to have that app which has some
computationally intensive code but by
and large the rest of the app is is not
dependent upon the performance of a g5
system and so you might break out a pup
such that you put the computational
intensity portion into a runtime library
you tune that very heavily for g5 and
leave the rest of your code as g4 g3 and
you can produce runtime libraries for
each category of system you can do that
by turning on the mCP you and and
getting g5 instructions and M tune and
getting g5 scheduling let's suppose
though that your app also uses long long
or double instruction are double data
types then you may want to take
advantage of the 64-bit power arithmetic
power of the g5 and what we have
provided you use the Empire of PC 64
switch is that you actually enable
64-bit arithmetic and and it does
amazing things than with your long long
arithmetic or your doubles and
loading and storing 64 bits and doing
arithmetic on that believe me you
applaud once you've had a chance to
taste it if you're using that we have
always encouraged you to use the
optimization for space dash OS because
that in the system can have a big impact
and so we're not discouraging that now
if you have code that is not
computationally intensive by all means
build it with Dashie OS what we are
encouraging you though is be a little
more adventuresome if in fact you want
to get performance out of this machine
you need to deal with the higher levels
of optimization 0203 if at all possible
and it lends itself to your code you
want to deal with things like the
alignment of loops and jumps and
functions and make sure that they're
aligned on proper boundaries so that you
can if you have fall along some of the
architectural types of discussions and
David will be talking about this a
little bit in a moment alignment can be
very important in terms of extracting
speed so let me call David Edelstein up
to the stage David and others within IBM
we've worked very heavily with us on
optimizing for the g5 and in the three
dot 3 release Davis all right thanks
very much
so my name is David Edelson and i work
at IBM research my main focus there is
on open-source issues and technology
particularly GCC I'm glad to see so many
people here at the conference interested
in GCC so first let me give you a little
idea of what I'm going to talk about in
this presentation it was talking about
the powerpc 970 processor and issues in
the processor that important for
compiler to target to get the highest
performance we're also going to talk
about how we have optimized GCC to
extract that best performance on this
processor that Apple is now using and
we're going to mention a little bit
about the future optimizations that are
gonna be coming down the pike and later
releases of GCC and about how IBM and
Apple are both working together with the
open source community to engage them and
produce the best compiler for the
PowerPC processors so let's start with a
little bit of information about this big
step in processor performance we now
have a 64-bit PowerPC processor on the
desktop the PowerPC architecture was
designed from day one as a 64-bit
architecture the previous
implementations have been the 32-bit
subset and now we are having
implementation in Apple's computers that
uses the full 64-bit architecture this
and these this architecture has
instructions that operate on both 32-bit
size data and 64-bit size data and in
64-bit mode when is operating on twice
the amount of data and it's the same
performance whether you're in the 32-bit
mode or 64-bit mode same latency the
same speed of the instructions and
they're getting operating on twice the
amount of data this off this processor
has a lot of resources available at its
disposal to attack whatever application
you have to throw at it has to complete
symmetric floating-point units it has
two symmetric load store units it has to
almost symmetric instruction integer
units in this processor and these are a
lot of capabilities now to bring to bear
on your problems and these this increase
and resources is an increase in
performance for your application
so this is a pictorial depiction of the
processor core in the 970 I just want
you to have a visual representation for
this processor in the upcoming slides so
let's go through and talk about how an
instruction throat flows through this
processor first instructions are fetched
from the l1 cache into the instruction
queue and in this instruction queue the
process the instructions are then
decoded and placed into the dispatch
group and up to five instructions can be
dispatched at a time to the various
instruction function units issue cues
from the issue queues you can dispatch
to any of these 12 function units in the
processor so this is a lot of resources
a very powerful ship a lot of complexity
that the compiler needs to harness to
give you the best performance so what
are some of these challenges the
compiler needs to deal with first of all
the processor is dealing with internal
ox that the actual function units are
operating on operations that are mostly
141 equivalent to PowerPC instructions
but some instructions that are more
complicated than the PowerPC
architecture are broken apart and that's
what the function units actually operate
on examples of these instructions are
load algebraic which is a load with a
sign extension a load of up and update
form which is a load and then updating
the address register various forms of
stores which although it's not not all
of them are cracked is actually issued
as a register access and as an address
generation and implicit compares which
are the mnemonics that have a dot at the
end where one performs a logical or
arithmetic operation and then in
comparison with 0 the stores result in a
condition register and finally the multi
field condition register operations
where one is performing a condition
register logical operation on multiple
condition register fields at the same
time those are examples of the
user application instructions that are
cracked another area that the complexity
is the dispatch groups so for these
dispatch groups The Dispatch group isn't
completely symmetric and when it's which
instruction can be placed into which
slot and the dispatch group for instance
move to and from special purpose
registers is placed in slot one
divisions are placements lot too and the
slots also are directed to various
versions of the dual function unit so
this is another area where the compiler
needs to be careful to achieve the best
performance and finally the instructions
are brought from the instruction queue
into the dispatch group in order but
then once the dispatch troops are
dispatched to the various function units
the functioning to the issue queues for
the function is the function units are
able to pull the instructions out of
order as resources are available for
them to produce the most performance and
get the most parallelism out of the
resources available and then the
instructions are recombined at the end
and completed as an entire dispatch
group so there's a lot of parallelism
available if the compiler is able to
take advantage of it so what have we
done in the compiler to achieve this
performance first of all we're
preferring the non cracked forms of
instructions to again allow the
processor the greatest amount of
flexibility in which instructions it can
dispatch as I mentioned about the
dispatch groups the compiler is also
trying to order the instructions in the
sequences they will be placed into
dispatch slot to allow the maximum
number of instructions to be dispatched
at one time to again allow the massive
maximum amount of functions to be in use
to work on the various problems there's
also the issue of balancing the use of
the functions we have these two dual
function units and we want to make sure
that one unit is not starved while the
other one is overloaded so we need to
make sure that we're issuing
instructions to keep both units occupied
and get the maximum performance from
this chip additionally there are issues
with dependent instructions where it's
best for the chip if those dependent
instructions are placed into
separate dispatch groups to avoid solved
within the processor and we've also done
various branch optimizations to deal
with other restrictions in the processor
that could potentially produce stalls so
there's a lot of issues there that the
compiler needs to pay attention to and
finally as Ron mentioned a very
important issue is the alignment of
instructions because the processor
instruction fetch isn't is fetching 32
bytes at the time that's eight
instructions into the instruction queue
but it's etching those instructions on a
32 byte boundary so if one is jumping
into the middle of a group of
instructions that isn't on a 32 bytes
boundary such as a loop such as a jump
to the beginning of a function or label
then you're wasting the instruction sets
bandwidth if that's not on the first on
the appropriate boundary so again we
have additional options and the compiler
and the compilers when tuned to generate
instructions on that boundary if it
isn't going to decrease the performance
by adding too many other instructions to
achieve that alignment so I want to make
sure you understand that while this
processor has a lot of capabilities that
the compiler can leverage that this
processor works very well with any sort
of code that you're going to throw up
that if you're working on g3 or g4 code
there's a lot of dynamic capability in
the processor to extract the most
performance out of that you can work
with the compiler to achieve the maximum
performance and get that little extra
percent but if you're working for on an
application that needs to be targeted at
g3 and g4 and the new g5 that
application will scream on all of these
processors and it'll scream on the g5 as
well so this processor will not just
fall down if presented with g4 code so
how can you help the compiler to produce
better code now that we discussed what
the compiler what we've done in the
compiler group to try to help to knit
for this processor well first of all one
thing that you need to do is to make
sure it's just that the compiler can be
as aggressive as possible in its
transformations of the code and one of
these areas is to try to make sure that
the compiler doesn't need to be
more conservative than need be an area
where this is important is in aliasing
that's where the compiler cannot tell or
where two different memory two different
accesses to memory could potentially two
variables could point to the same place
in memory and so if the compiler cannot
distinguish this the compiler needs to
be more conservative to ensure that it's
going to perform the calculations in the
appropriate order so what you can do to
allow the compiler to see and understand
more of the procedure that you're
working on is to use local variables and
to avoid taking the addresses of
variables and this also includes areas
where the calling convention may
implicitly pass something by an address
because then the compiler needs to sort
of throw up its hands it can't fully
understand the consequences of what the
something may be happening behind its
back so that's one area where you can
help the compiler produce more effective
code another area is in simplifying
loops or if you can make this loop as
simple as possible and as direct as
possible the compiler is much more
opportunity to make transformations that
will improve performance one example of
this is to not have changes in slow
control inside the loop so for instance
if you have a loop that has a branch
inside the loop if it's possible it'd be
better to move that branch that
conditional outside of the loop and
actually duplicate the loop in both
branches of the conditional and that
allows the compiler to then optimize
each of those loops much more
effectively when it can better
understand exactly what's going to
happen another area is indexes into
arrays again try to have a simplified
and index as possible so again the
compiler can understand what's going on
and make transformations with
prefetching and other sorts of
optimizations that would be much more
effective in the throughput of this
processor and finally is obeying the
type rules the type rules is something
that is essentially an agreement between
the programmer and the language about
how you're going to use the various
types and if you use the types
appropriately and don't start changing
accesses behind the compilers back in
ways that it doesn't expect you can use
the most
aggressive optimizations as Ron
mentioned and get the best performance
from your program so let me talk a
little bit about where this technology
came from that a lot of this work that
we've been doing comes from IBM vast
experience in developing compilers over
the past decades including some of the
earliest compilers for computers and so
we have a worldwide research and
development organization that has been
brought to bear in partnership with
apple and improving this compiler for
the g5 processor some of this involves
taking the technology that IBM has
developed for its power for processor
from which the 970 was derived and used
in developing IBM own compiler taking
that knowledge taking that experience
and driving that technology and that
understanding into GCC to leveraging all
of that history of development and we're
trying to using all of that to exploit
this processor and give Apple and its
customers the best performance possible
now let me mention a little bit about
where GCC is going in the future there's
a lot of very exciting optimizations
that are going to be included in the
compiler in the future which will get
further enhance the performance of this
processor we have a new register
allocator is coming there is
improvements in the instruction
scheduler which will allow even better
ability to model these complicated
dispatch groups that I mentioned there's
work on software pipelining which will
help improve floating-point performance
there's work on an SS a optimization
infrastructure which allows one to
describe the program in a way that
allows much more aggressive
optimizations this will allow it easier
implementation of loop optimizations and
auto vectorization in the future further
work on interprocedural optimizations to
be able to again have the compiler
understand more of the program
understand what's going to happen with
aliasing and work past limitations the
programmer may not have intended profile
directed feedback so that the compiler
can reorder the instructions to take
advantage of how the application is
actually run with the data sets that you
have and of course continued improvement
in the compiler speed to more rapidly
generate the code
so all of this stems from this
partnership that IBM and Apple have in
developing and further improving GCC we
were both very committed to GCC and to
the open source community there are a
large number of developers for GCC
inside Apple and inside IBM there I am a
member of the GCC steering committee and
a member of Ron's team is on the GCC
steering committee I'm one of the
maintainer of the PowerPC toward of the
compiler and a member of Ron's team is
micah maintainer on the compiler and we
are fully engaged with this community to
help design the future of this compiler
and taking a leadership position to make
sure that this is the best compiler for
apple systems and for the powerpc and so
just want to let you know that as not
only are we working aggressively on the
processor and the hardware but there's a
lot of excitement to come and further
improving the performance of the system
from the software and the work on the
compiler as well and so I hope that
you're excited as well and now I also
just want to quickly mention the thanks
to John Hannibal Stokes for the use of
one of his graphics in this talk and now
lend it back over to rot
[Applause]
actually it's a pretty exciting time for
us in the compiler world when you're
presented with a challenge like this it
just makes your day or make sure your
future directions well as you can see
we've just embarked on this this journey
with the new processor and and
extracting the performance from that and
we really consider our role to be one of
trying to make make this process at work
for you without you having to do jump
through hoops or go through a lot of
gyrations right now we're telling you
please do a few durations if you want to
get the performance out but we're
working as David showed you on any
number of areas within the GCC community
to take the optimization capabilities of
the canoe compiler to the next level we
also don't consider our work done in
terms of compiled speed I think you
agree we've made some really dramatic
progress in the past year and and if I
were you I would expect from us that
will make as good a progress in the
coming year because we're going to nail
performance that that's really important
and we want to we want to remove this
compiler from being an obstruction to
you getting your work done in terms of
language features will move along at a
slower pace because the language is
moving at a slower pace today but but
you can count on us continuing to move
towards full compliance with the ante
and ISO standards
so this even though it's being jammed
today is being offered to you and as a
part of the Xcode tools package there's
documentation in that package that you
can relieve that you can reach those the
release notes one piece of documentation
that that you'll probably want to look
for is in terms of performance tuning
your code and I would encourage you to
attend the session which occurs the next
session I don't think it's in this hall
I may actually have a slide on that okay
anyways there's a formal session during
the next period of time and I would
encourage you to attend that I was at
the judge session that preceded this and
I was happy to see an overflow room
there we've got some dramatic
capabilities with our tools to help you
improve the performance of your code if
you have contacts that you want to make
goffe do Georgie who's our technology
manager and you'll meet him just a
moment his email address there's a
feedback address for the development
tools and of course we're always looking
for bug reports well I guess we're not
happily looking for bug reports that we
appreciate the feedback here's the 305
in presidio as the performance tools
section and I was talking to some of the
other sessions that you might be
interested in as Apple script studio
carbon development and so forth and we
encourage you tomorrow there will be a
feedback forum where you can comment and
let us know what you would like to
feedback to us and give us your
impression of the tools
you