Hi Mariah,

Thanks for the offer of help! That is great news for our project, and
I think your expertise will be of great value to our project!!

William Stein passed on to me that you looked at the list of things
that we want to do and thought "the work looked interesting". If there
is some particular part of the project that interests you more than
another, do let us know about that. We like to keep our developers
happy, even if MPIR development is part of their work duties!!

There's certainly a lot of build system (autotools) stuff that needs
doing. There's a few known bugs for systems on SkyNet, and we are just
at the point where we'd like to do build testing of our imminent
release (perhaps some kind of automated build testing on SkyNet) and
set up a decent website for the project.

I propose that we, as a group, quickly put together a prioritised list
of things we'd like to have you work on, preferably starting with easy
ones.

To give you an executive summary of what MPIR is about, there is the
following, which may also be of use to other developers and
prospective developers:

* MPIR is essentially a fork of the GNU Multiprecision project GMP
(hosted at http://gmplib.org/). Our code base was initially taken from
GMP v 4.2.1.

* We have the aims of having an open repository and being developer
friendly, of supporting parallel architectures and multicore machines,
sticking with LGPL version 2 (or at the user's option, any later
version of the license) for the time being, and being vendor friendly
(e.g. we aim to fully support the Sun, Apple and Microsoft MSVC
compilers).

* GMP is used by most open and proprietary mathematics software, and
MPIR will be used by Sage. It is our hope that other projects will
migrate to MPIR.

* So far we have merged patches into MPIR for the following:
 - Jason Martin's Core 2 Patches for speed increases on Core 2

 - Patches from SiCortex for their MIPS hardware

 - Pierrick Gaudry's patches for AMD 64 for a speed increase on AMD 64

 - Brian Gladman's MSVC port of GMP to Microsoft MSVC

 - Fixed some issues with compilation on Apple and Sun compilers

 - Better detection of recent AMD and Intel chips

 - All 64 bit x86 assembly code has been converted from gas (AT&T) to
yasm (Intel format) - the yasm assembler is included as part of the
MPIR distribution

 - Inclusion of Niel's Moller's fast GCD patches

 - Lots of other minor bug fixes and changes including many associated
with changing the name GMP to MPIR throughout

* For fun we sometimes refer to MPIR as eMPIRe!

* The website is at http://www.mpir.org/
  It contains links to our bug tracker (pretty much up-to-date), our
wiki (hopelessly out-of-date: e.g. we no longer have mandatory patch
review procedures and everything has been running in a much less
formal manner than is specified there) and this, our development list.

* Our source svn repository is currently http://modular.math.jmu.edu/svn/mpir
  Jason Martin can easily set you up with write access, but read
access is anonymous.

* The basic structure of the source tree is as follows:
 - A directory called mpn contains code for functions of the form
mpn_blah(). These are very low level multiprecision functions. They
usually take pointers to arrays of limbs (32 or 64 bit machine words
dependent on the ABI selected at configuration time and on the
capabilities of the hardware) which represent unsigned multiprecision
integers, and various counts, which are the lengths of the arrays of
limbs. They are documented in the section called "low level functions"
in the documentation which can be accessed here:
http://www.nada.kth.se/~tege/gmp/gmp-man-4.2.4.pdf

- Within the mpn directory are numerous directories for assembly code
for a wide range of hardware (much of it outdated and possibly not
even recently tested) -- we are actively working on improving it

- There is also the directory mpn/generic which contains generic C
code for various functions where native assembly code is not available
and for higher
level mpn functions which would be impractical to implement in assembly

- The directory mpz contains a high level multiprecision integer
library. The functions in this library call subordinate mpn functions
to perform lower level multiprecision operations. The mpz functions
are of the form mpz_blah(), which take mpz_t parameters, and
mpz_blah_ui() (for functions which also take unsigned long parameters)
and mpz_blah_si() (for functions which also take signed long
parameters). An mpz_t is an array of length 1 of an __mpz_struct which
contains fields for all the data used to represent a multiprecision
integer, including a sign/size limb, an array of limbs representing
the integer and an alloc field for the number of limbs currently
allocated. mpz_blah*() functions do all their own memory allocation.
The mpz_blah*() functions are documented in the section entitled
"Integer Functions" in the documentation.

- There are also directories mpf and mpq for high level functions
dealing with multiprecision rationals and floats, however these
functions do not tend to concern us much so far.

- When built, GMP relies on files longlong.h (which contains
additional assembly macros for a range of machines for doing longlong,
i.e. 2 limb, arithmetic), gmp.h (which contains prototypes for all
user visible functions) and gmp-impl.h (which contains prototypes and
some macros for internal functions - it is included by all of the
files in the mpz directory). There are also c++ versions of gmp.h and
gmp-impl.h.

- the tests directory contains tests for each mpz, mpf and mpq
function (including regression tests) and a program called try (type
make try to build it) which is used for testing mpn functions
extensively

- the tune directory contains code for a tuning program (make tune to
build it). It generates data for the machine dependent mpn/*
directories that goes in the various files called gmp-mparam.h. It
tunes crossovers and parameters for various algorithms implemented in
MPIR.

- the doc directory contains documentation, including mpir.texi which
when built with make doc, builds the mpir documentation (very similar
to the above linked GMP documentation). The doc/devel directory
contains some documentation which may or may not be of use to
developers.

- obviously the autotools stuff is in the main directory. It include
config.guess, config.sub, configfsf.guess and configfsf.sub which
include scripts to detect various processors, operating systems and
machines. They are run by the autotools configuration. Autotools also
relies on libtool, a version of which is included with MPIR. gmp.h is
modified per architecture by autotools.

- the main source directory also contains various files for global
MPIR stuff, such as the memory manager, assertion code and some tables
used by various functions, which need to be rebuilt.

To build MPIR simply do:

./configure
make
make check

Note make clean and make dist-clean are also supported. These are all
hooked up to do the appropriate things for the yasm source tree,
included in the yasm directory (via a hack contained in the yasm-build
directory). Note yasm is only built on x86 hardware.

I hope that is useful for a general introduction to the project.
Please don't hesitate to ask us questions.

I would think that a first step might be to get familiarised with the
tickets in the bug tracker (note many of the blockers in red have been
resolved, but a couple are outstanding - I know Jason is still working
on the GCD patches - they currently run slow on x86_64 - but I know
the Sun C++ issues have not been dealt with for example). I will give
you a trac account as soon as I recall how to do it. If all goes well,
I'm hoping you will end up managing the trac server. :-)

Bill.


2008/12/4 Mariah <[EMAIL PROTECTED]>:
>
> Bill Hart,
>
> My employer has given me permission to spend some of my time working
> on MPIR development.  I understand that you (and this group) are where
> I should find possible projects to work on.  I would appreciate some
> small
> projects to start, so that I can learn about MPIR.  While I have only
> basic
> knowledge about multiple-precision arithmetic, I do know about GNU gcc
> compilers
> and debugging, C programming, web development, and have some
> knowledge
> of autoconf tools.
>
> I must emphasize that I will only be able to work part-time on MPIR.
> My employer
> has first call on my time, and there may be periods when I go silent
> for a few
> days will working on something else.
>
> Mariah Lenox
> >
>

--~--~---------~--~----~------------~-------~--~----~
You received this message because you are subscribed to the Google Groups 
"mpir-devel" group.
To post to this group, send email to mpir-devel@googlegroups.com
To unsubscribe from this group, send email to [EMAIL PROTECTED]
For more options, visit this group at 
http://groups.google.com/group/mpir-devel?hl=en
-~----------~----~----~----~------~----~------~--~---

Reply via email to