Sharedwww / msri07 / sched.sageOpen in CoCalc
Author: William A. Stein
1
class Speaker:
2
def __init__(self, name, employer=None, url=None, email=None, status=None, title=None, abstract=None):
3
self.name = name
4
self.employer = employer
5
self.email = email
6
self.url = url
7
self.title = title
8
self.abstract = abstract
9
self.status = status
10
if status != 'invited' and status != 'contributed':
11
raise ValueError, '%s: "%s"'%(name, status)
12
13
def __repr__(self):
14
return self.name
15
16
def last_name(self):
17
name = self.name
18
if ' and ' in self.name:
19
name = self.name.split(' and ')[0]
20
return ' '.join(name.split()[1:])
21
22
def first_name(self):
23
return self.name.split()[0]
24
25
def __cmp__(self, right):
26
return cmp(self.last_name(), right.last_name())
27
28
def tag(self):
29
return self.name.replace(' ','')
30
31
def html_full(self):
32
return """
33
<a name="%s">
34
<h2><font color="darkred"><b>%s</b></font>:
35
<font color="#333333"><i>%s</i></font><br></h2>
36
%s<br><br>
37
%s"""%(
38
self.tag(), self.last_name(), self.title, self.html_name(), self.html_abstract())
39
40
def html_abstract(self):
41
s = self.abstract.replace('\n\n','<p>').replace('``','"').replace("''",'"')
42
if '*' in s:
43
i = s.find('*')
44
s = s.replace('*', '<li>')
45
s = s[:i] + '<ul>' + s[i:]
46
s += '</ul>'
47
return s
48
49
def html_short(self):
50
return '%s<br><b><i>%s</i></b>'%(self.html_name(), self.html_title())
51
52
def html_name(self):
53
if self.url:
54
url = self.url
55
else:
56
url = 'mailto:%s'%self.email
57
if self.employer:
58
emp = ' - %s'%self.employer
59
else:
60
emp = ''
61
return '<a href="%s">%s %s</a>'%(url, self.name, emp)
62
63
def html_title(self):
64
return '<a href="#%s">%s</a>'%(self.tag(), self.title)
65
66
67
############################################################################
68
69
70
def wiki_full(self):
71
return """== %s: %s ==
72
73
[%s %s %s]
74
75
%s
76
"""%(self.last_name(), self.title, self.wiki_url(), self.name, self.wiki_employer(), self.wiki_abstract())
77
78
def wiki_employer(self):
79
if self.employer == '':
80
return ''
81
else:
82
return '- %s'%self.employer
83
84
def wiki_abstract(self):
85
ab = self.abstract.replace('``','"').replace("''",'"')
86
if '*' in ab:
87
return ab.strip()
88
return misc.word_wrap(ab).strip()
89
90
def wiki_short(self):
91
return '%s<br>%s'%(self.wiki_name(), self.wiki_title())
92
93
def wiki_url(self):
94
if self.url:
95
url = self.url
96
else:
97
url = 'mailto:%s'%self.email
98
return url
99
100
101
############################################################################
102
103
def latex_full(self):
104
s = """
105
{\\large \\bf %s: {\\em\sf %s}}\\vspace{1ex}\\newline
106
{\em %s}\\vspace{1ex}\\newline
107
\url{%s}\\vspace{1ex}\\newline
108
{%s}
109
"""%(
110
self.last_name(), self.title, self.latex_name(), self.latex_url(), self.latex_abstract())
111
return s.strip()
112
113
def latex_abstract(self):
114
s = self.abstract
115
if '*' in s:
116
i = s.find('*')
117
s = s.replace('*', '\\item')
118
s = s[:i] + '\\begin{itemize}' + s[i:]
119
s += '\\end{itemize}'
120
return s
121
122
def latex_short(self):
123
return '%s - {\\em\\sf %s}'%(self.last_name(), self.title)
124
125
def latex_name(self):
126
if self.employer:
127
emp = ' - %s'%self.employer
128
else:
129
emp = ''
130
return '%s %s'%(self.name, emp)
131
132
def latex_url(self):
133
if self.url:
134
return self.url
135
return self.email
136
137
138
139
speakers = [\
140
Speaker('David Bailey',
141
'Lawrence Berkeley Labs (LBL)',
142
'http://crd.lbl.gov/~dhbailey/',
143
'',
144
'invited',
145
'Experimental Mathematics and High-Performance Computing',
146
"""
147
Recent developments in ``experimental mathematics'' have underscored the value of high-performance computing in modern mathematical research. The most frequent computations that arise here are high-precision (typically several-hundred-digit accuracy) evaluations of integrals and series, together with integer relation detections using the ``PSLQ'' algorithm. Some recent highlights in this arena include: (2) the discovery of ``BBP'-type formulas for various mathematical constants, including pi and log(2); (3) the discovery of analytic evaluations for several classes of multivariate zeta sums; (4) the discovery of Apery-like formulas for the Riemann zeta function at integer arguments; and (5) the discovery of analytic evaluations and linear relations among certain classes of definite integrals that arise in mathematical physics. The talk will include a live demo of the ``experimental mathematician's toolkit''.
148
"""),
149
Speaker('Robert Bradshaw',
150
'University of Washington',
151
'',
152
'[email protected]',
153
'contributed',
154
'Loosely Dependent Parallel Processes',
155
"""
156
Many parallel computational algorithms involve dividing the problem into several smaller tasks and running each task in isolation in parallel. Often these tasks are the same procedure over a set of varying parameters. Inter-process communication might not be needed, but the results of one task may influence what subsequent tasks need to be performed. I will discuss the concept of job generators, or custom-written tasks that generate other tasks and process their feedback. I would discuss this specifically in the context of integer factorization.
157
"""),
158
159
Speaker('Henry Cohn',
160
'Microsoft Research',
161
'http://research.microsoft.com/~cohn/',
162
'',
163
'invited',
164
'Parallel Computation Tools for Research: A Wishlist',
165
''),
166
167
Speaker('Gene Cooperman',
168
'Northeastern University',
169
'http://www.ccs.neu.edu/home/gene/',
170
'',
171
'invited',
172
'Disk-Based Parallel Computing: A New Paradigm',
173
"""
174
One observes that 100 local commodity disks of an array have approximately the same streaming bandwidth as a single RAM subsystem. Hence, it is proposed to treat a cluster as if it were a single computer with tens of terabytes of data, and with RAM serving as cache for disk. This makes feasible the solution of truly large problems that are currently space-limited. We also briefly summarize other recent activities of our working group: lessons from supporting ParGAP and ParGCL; progress toward showing that 20 moves suffice to solve Rubik's cube; lessons about marshalling from support of ParGeant4 (parallelization of a million-line program at CERN); and experiences at the SCIEnce workshop (symbolic-computing.org), part of a 5-year, 3.2 million euro, European Union project. Our new distributed checkpointing package now provides a distributed analog of a SAVE-WORKSPACE command, for use in component-based symbolic software, such as SAGE."""),
175
176
Speaker('Alan Edelman',
177
'MIT',
178
'http://www-math.mit.edu/~edelman/',
179
'',
180
'invited',
181
'Interactive Parallel Supercomputing: Today: MATLAB(r) and Python coming Cutting Edge: Symbolic Parallelism with Mathematica(r) and MAPLE(r)',
182
"""Star-P is a unique technology offered by Interactive Supercomputing after
183
nurturing at MIT. Star-P through its abstractions is solving the ease of use
184
problem that has plagued supercomputing. Some of the innovative features of
185
Star-P are the ability to program in MATLAB, hook in task parallel codes
186
written using a processor free abstraction, hook in existing parallel codes,
187
and obtain the performance that represents the HPC promise. All this is
188
through a client/server interface. Other clients such as Python or R could
189
be possible. The MATLAB, Python, or R becomes the "browser." Parallel
190
computing remains challenging, compared to serial coding but it is now that
191
much easier compared to solutions such as MPI. Users of MPI can plug in
192
their previously written codes and libraries and continue forward in Star-P.
193
194
Numerical computing is challenging enough in a parallel environment,
195
symbolic computing will require even more research and more challenging
196
problems to be solved. In this talk we will demonstrate the possibilities
197
and the pitfalls.
198
"""),
199
200
Speaker('Brian Granger',
201
'Tech X Corp.',
202
'http://txcorp.com',
203
'',
204
'invited',
205
'Interactive Parallel Computing using Python and IPython',
206
"""
207
Interactive computing environments, such as Matlab, IDL and
208
Mathematica are popular among researchers because their
209
interactive nature is well matched to the exploratory nature of
210
research. However, these systems have one critical weakness:
211
they are not designed to take advantage of parallel computing
212
hardware such as multi-core CPUs, clusters and supercomputers.
213
Thus, researchers usually turn to non-interactive compiled
214
languages, such as C/C++/Fortran when parallelism is needed.
215
216
In this talk I will describe recent work on the IPython project
217
to implement a software architecture that allows parallel
218
applications to be developed, debugged, tested, executed and
219
monitored in a fully interactive manner using the Python
220
programming language. This system is fully functional and allows
221
many types of parallelism to be expressed, including message
222
passing (using MPI), task farming, shared memory, and custom user
223
defined approaches. I will describe the architecture, provide an
224
overview of its basic usage and then provide more sophisticated
225
examples of how it can be used in the development of new parallel
226
algorithms. Because IPython is one of the components of the SAGE
227
system, I will also discuss how IPython's parallel computing
228
capabilities can be used in that context.
229
"""),
230
231
Speaker('Robert Harrison',
232
'Oak Ridge National Lab',
233
'http://www.csm.ornl.gov/ccsg/html/staff/harrison.html',
234
'',
235
'invited',
236
'Science at the petascale: tools in the tool box',
237
"""
238
Petascale computing will require coordinating the actions of 100,000+
239
processors, and directing the flow of data between up to six levels
240
of memory hierarchy and along channels that differ by over a factor of
241
100 in bandwidth. Amdahl's law requires that petascale applications
242
have less than 0.001% sequential or replicated work in order to
243
be at least 50% efficient. These are profound challenges for all but
244
the most regular or embarrassingly parallel applications, yet we also
245
demand that not just bigger and better, but fundamentally new science.
246
In this presentation I will discuss how we are attempting to confront
247
simultaneously the complexities of petascale computation while
248
increasing our scientific productivity. I hope that I can convince you
249
that our development of MADNESS (multiresolution adaptive numerical
250
scientific simulation) is not as crazy as it sounds.
251
252
This work is funded by the U.S. Department of Energy, the division of
253
Basic Energy Science, Office of Science, and was performed in part
254
using resources of the National Center for Computational Sciences, both
255
under contract DE-AC05-00OR22725 with Oak Ridge National Laboratory.
256
"""),
257
258
Speaker('Bill Hart',
259
'Warwick',
260
'http://www.maths.warwick.ac.uk/~masfaw/',
261
'',
262
'invited',
263
'Parallel Computation in Number Theory',
264
"""
265
This talk will have two sections. The first will
266
introduce a new library for number theory which is
267
under development, called FLINT. I will discuss the
268
various algorithms already available in FLINT, compare
269
them with similar implementations available elsewhere,
270
and speak about what the future holds for FLINT, with
271
the focus on parallel processing and integration into
272
Pari and the SAGE package.
273
274
The second part of the talk will focus on low level
275
implementation details of parallel algorithms in
276
number theory. In particular I will discuss the design
277
decisions that we have made so far in the FLINT
278
library to facilitate multicore and multiprocessor
279
platforms.
280
281
If time permits, there will be a live demonstration.
282
"""
283
),
284
285
Speaker('Yozo Hida',
286
'UC Berkeley',
287
'http://www.cs.berkeley.edu/~yozo/',
288
'',
289
'invited',
290
'Moving Lapack and ScaLapack to Higher Precision without Too Much Work',
291
"""I will be discussing recent developments in Lapack and ScaLapack
292
libraries, along with some recent work on incorporating higher
293
precision into Lapack and ScaLapack."""),
294
295
Speaker('Samee Khan',
296
'University of Texas, Arlington',
297
'',
298
'[email protected]',
299
'contributed',
300
'Game Theoretical Solutions for Data Replication in Distributed Computing Systems',
301
"""
302
Data replication is an essential technique employed to reduce the user
303
perceived access time in distributed computing systems. One can find numerous
304
algorithms that address the data replication problem (DRP) each contributing in
305
its own way. These range from the traditional mathematical optimization
306
techniques, such as, linear programming, dynamic programming, etc. to the
307
biologically inspired meta-heuristics. We aim to introduce game theory as a new
308
oracle to tackle the data replication problem. The beauty of the game theory
309
lies in its flexibility and distributed architecture, which is well-suited to
310
address the DRP. We will specifically use action theory (a special branch of
311
game theory) to identify techniques that will effectively and efficiently solve
312
the DRP. Game theory and its necessary properties are briefly introduced,
313
followed by a through and detailed mapping of the possible game theoretical
314
techniques and DRP. As an example, we derive a game theoretical algorithm for
315
the DRP, and propose several extensions of it. An elaborate experimental setup
316
is also detailed, where the derived algorithm is comprehensively evaluated
317
against three conventional techniques, branch and bound, greedy and genetic
318
algorithms.
319
"""),
320
321
Speaker('Ilias Kotsireas',
322
'Laurier University, Canada',
323
'',
324
'[email protected]',
325
'contributed',
326
'Combinatorial Designs: constructions, algorithms and new results',
327
"""
328
We plan to describe recent progress in the search for combinatorial designs of
329
high order. This progress has been achieved via some algorithmic concepts, such
330
as the periodic autocorrelation function, the discrete Fourier transform and
331
the power spectral density criterion, in conjunction with heuristic
332
observations on plausible patterns for the locations of zero elements. The
333
discovery of such patterns is done using meta-programming and automatic code
334
generation (and perhaps very soon data mining algorithms) and reveals the
335
remarkable phenomenon of crystalization, which does not yet possess a
336
satisfactory explanation. The resulting algorithms are amenable to parallelism
337
and we have implemented them on supercomputers, typically as implicit parallel
338
algorithms.
339
"""),
340
341
Speaker('Anton Leykin',
342
'IMA (Minessota)',
343
'',
344
'[email protected]',
345
'contributed',
346
'Parallel computation of Grobner bases in the Weyl algebra',
347
"""
348
The usual machinery of Grobner bases can be applied to non-commutative algebras
349
of the so-called solvable type. One of them, the Weyl algebra, plays the
350
central role in the computations with $D$-modules. The practical complexity of
351
the Grobner bases computation in the Weyl algebra is much higher than in the
352
(commutative) polynomial rings, therefore, calling naturally for parallel
353
computation. We have developed an algorithm to perform such computation
354
employing the master-slave paradigm. Our implementation, which has been carried
355
out in C++ using MPI, draws ideas from both Buchberger algorithm and
356
Faugere's $F_4$. It exhibits better speedups for the Weyl algebra in
357
comparison to polynomial problems of the similar size.
358
"""),
359
360
Speaker('Jason Martin',
361
'James Madison University',
362
'http://www.math.jmu.edu/~martin/',
363
'',
364
'invited',
365
'MPMPLAPACK: The Massively Parallel Multi-Precision Linear Algebra Package',
366
"""
367
For several decades, researchers in the applied fields have had access
368
to powerful linear algebra packages designed to run on massively
369
parallel systems. Libraries such as ScaLAPACK and PLAPACK provide a
370
rich set of functions (usually based on BLAS) for performing linear
371
algebra over single or double precision real or complex data.
372
However, such libraries are of limited use to researchers in discrete
373
mathematics who often need to compute with multi-precision data types.
374
375
This talk will cover a massively parallel multi-precision linear
376
algebra package that I am attempting to write. The goal of this C/MPI
377
library is to provide drop-in parallel functionality to existing
378
number theory and algebraic geometry programs (such as Pari, Sage, and
379
Macaulay2) while preserving enough flexibility to eventually become a
380
full multi-precision version of PLAPACK. I will describe some
381
architectural assumptions, design descisions, and benchmarks made so
382
far and actively solicit input from the audience (I'll buy coffee for
383
the person who suggests the best alternative to the current name).
384
"""),
385
386
Speaker('Marc Moreno Maza',
387
'Western Ontario',
388
'http://www.csd.uwo.ca/~moreno/',
389
'',
390
'invited',
391
'Component-level Parallelization of Triangular Decompositions',
392
"""
393
We discuss the parallelization of algorithms for solving polynomial systems symbolically by way of triangular decompositions. We introduce a component-level parallelism for which the number of processors in use depends on the geometry of the solution set of the input system. Our long term goal is to achieve an efficient multi-level parallelism: coarse grained (component) level for tasks computing geometric objects in the solution sets, and medium/fine grained level for polynomial arithmetic such as GCD/resultant computation within each task.
394
395
Component-level parallelism belongs to the class of dynamic irregular parallel applications, which leads us to address the following questions: How to discover and use geometrical information, at an early stage of the solving process, that would be favorable to component-level parallel execution and load balancing? How to use this level of parallel execution to effectively eliminate unnecessary computations? What implementation mechanisms are feasible?
396
397
We report on the effectiveness of the approaches that we have applied, including ``modular methods'', ``solving by decreasing order of dimension'', ``task cost estimation for guided scheduling''. We have realized a preliminary implementation on a SMP using multiprocessed parallelism in Aldor and shared memory segments for data communication. Our experimentation shows promising speedups for some well-know problems. We expect that this speedup would add a multiple factor to the speedup of medium/fine grained level parallelization as parallel GCD/resultant computations.
398
"""),
399
400
Speaker('Alfred Noel',
401
'UMass Boston / MIT',
402
'http://www.math.umb.edu/~anoel/',
403
'',
404
'invited',
405
'Structure and Representations of Real Reductive Lie Groups: A Computational Approach',
406
"""
407
I work with David Vogan (MIT) on the Atlas of Lie Groups and Representations. This is a project to make available information about representations of semi-simple Lie groups over real and p-adic fields. Of particular importance is the problem of the unitary dual: classifying all of the irreducible unitary representations of a given Lie group.
408
409
I will present some of the main ideas behind the current and very preliminary version of the software. I will provide some examples also. Currently, we are developing sequential algorithms that are implemented in C++. However, because of time and space complexity we are slowly moving in the direction of parallel computation. For example, David Vogan is experimenting with multi-threads in the K-L polynomials computation module.
410
411
This talk is in memory of Fokko du Cloux, the French mathematician who, until a few months ago, was the lead developer. He died this past November.
412
"""),
413
414
Speaker('Clement Pernet',
415
'University of Waterloo',
416
'',
417
'[email protected]oo.ca',
418
'invited',
419
'Parallelism perspectives for the LinBox library',
420
"""
421
LinBox is a generic library for efficient linear algebra with blackbox
422
or dense matrices over a finite field or Z. We first present a few
423
notions of the sequential implementations of selected problems, such
424
as the system resolution or multiple triangular system resolution, or
425
the chinese remaindering algorithm. Then we expose perspectives for
426
incorporating parallelism in LinBox, including multi-prime lifting for
427
system resolution over Q, or parallel chinese remaindering. This last
428
problem raises the difficult problem of combining early termination
429
and work-stealing techniques.
430
"""),
431
432
Speaker('Yi Qiang',
433
'University of Washington',
434
'',
435
'http://www.yiqiang.net/',
436
'invited',
437
'Distributed Computing using SAGE',
438
"""
439
Distributed SAGE (DSAGE) is a distributed computing framework for
440
SAGE which allows users to easily parallelize computations and
441
interact with them in a fluid and natural way. This talk will be
442
focused on the design and implementation of the distributed computing
443
framework in SAGE. I will describe the application of the
444
distributed computing framework to several problems, including the
445
problem of integer factorization and distributed ray tracing.
446
Demonstrations of using Distributed SAGE to tackle both problems will
447
be given plus information on how to parallelize your own problems. I
448
will also talk about design issues and considerations that have been
449
resolved or are yet unresolved in implementing Distributed SAGE.
450
"""),
451
452
Speaker('Jean-Louis Roch',
453
'ID-IMAG (France)',
454
'http://www-id.imag.fr/Laboratoire/Membres/Roch_Jean-Louis/perso.html',
455
'[email protected]',
456
'invited',
457
'Processor oblivious parallel algorithms with provable performances: applications',
458
"""
459
Based on a work-stealing schedule, the on-line coupling of two algorithms
460
(one sequential; the other one recursive parallel and fine grain) enables
461
the design of programs that scale with provable performances on various
462
parallel architectures, from multi-core machines to heterogeneous grids,
463
including processors with changing speeds. After presenting a generic scheme
464
and framework, on top of the middleware KAAPI/Athapascan that efficiently
465
supports work-stealing, we present practical applications such as: prefix
466
computation, real time 3D-reconstruction, Chinese remainder modular lifting
467
with early termination, data compression.
468
"""),
469
470
Speaker('Vladimir Tonchev',
471
'Michigan Tech',
472
'',
473
'[email protected]',
474
'contributed',
475
'Combinatorial designs and code synchronization',
476
"""
477
Difference systems of sets are combinatorial designs that arise in connection
478
with code synchronization. Algebraic constructions based on cyclic difference
479
sets and finite geometry and algorithms for finding optimal difference systems
480
of sets are discussed.
481
"""),
482
483
Speaker('Jan Verschelde',
484
'UIC',
485
'http://www.math.uic.edu/~jan/',
486
'[email protected]',
487
'invited',
488
'Parallel Homotopy Algorithms to Solve Polynomial Systems',
489
"""
490
A homotopy is a family of polynomial systems which defines a deformation
491
from a system with known solutions to a system whose solutions are needed.
492
Via dynamic load balancing we may distribute the solution paths so that a
493
close to optimal speed up is achieved. Polynomial systems -- such as the
494
9-point problem in mechanical design leading to 286,720 paths -- whose
495
solving required real supercomputers twenty years ago can now be handled
496
by modest personal cluster computers, and soon by multicore multiprocessor
497
workstations. Larger polynomial systems however may lead to more
498
numerical difficulties which may skew the timing results, so that
499
attention must be given to ``quality up'' as well. Modern homotopy methods
500
consist of sequences of different families of polynomial systems so that
501
not only the solution paths but also parametric polynomial systems must be
502
exchanged frequently.
503
"""),
504
505
Speaker('Thomas Wolf and Winfried Neun',
506
'',
507
'',
508
'[email protected] [email protected]',
509
'contributed',
510
'Parallel sparsening and simplification of systems of equations',
511
"""
512
In a Groebner Basis computation the guiding principle for pairing and
513
`reducing' equations is a total ordering of monomials or of derivatives for
514
differential Groebner Bases. If reduction based on an ordering is replaced by
515
reduction to minimize the number of terms of an equation through another
516
equation then on the downside the resulting (shorter) system does depend on the
517
order of pairing of equations for shortening but on the upside there are number
518
of advantages that makes this procedure a perfect addition/companion to the
519
Groebner Basis computation. Such features are:
520
521
* In contrast to Groebner Basis computations, this algorithm is safe in the sense that it does not need any significant amount of memory, even not temporarily.
522
* It is self-enforcing, i.e. the shorter equations become, the more useful for shortening other equations they potentially get.
523
* Equations in a sparse system are less coupled and a cost effective elimination strategy (ordering) is much easier to spot (for humans and computers) than for a dense system.
524
* Statistical tests show that the probability of random polynomials to factorize increases drastically the fewer terms a polynomial has.
525
* By experience the shortening of partial differential equations increases their chance to become ordinary differential equations which are usually easier to solve explicitly.
526
* The likelihood of shortenings to be possible is especially high for large overdetermined systems. This is because the number of pairings goes quadratically with the number of equations but for overdetermined systems, more equations does not automatically mean more unknowns to occur which potentially obstruct shortening by introducing terms that can not cancel.
527
* The algorithm offers a fine grain parallelization in the computation to shorten one equation with another one and a coarse grain parallelization in that any pair of two equations of a larger system can be processed in parallel. In the talk we will present the algorithm, show examples supporting the above statements and give a short demo.
528
"""),
529
530
Speaker('Kathy Yelick',
531
'UC Berkeley',
532
'http://www.cs.berkeley.edu/~yelick/',
533
'[email protected]',
534
'invited',
535
'Programming Models for Parallel Computing',
536
"""
537
The introduction of multicore processors into mainstream computing is
538
creating a revolution in software development. While Moore's
539
Law continues to hold, most of the increases in transistor density will be
540
used for explicit, software-visible parallelism, rather than increasing
541
clock rate. The major open question is how these machines will be
542
programmed.
543
In this talk I will give an overview of some of the hardware trends, and
544
describe programming techniques using Partitioned Global Address Space
545
(PGAS)
546
languages. PGAS languages have emerged as a viable alternative to message
547
passing programming models for large-scale parallel machines and clusters.
548
They also offer an alternative to shared memory programming models (such as
549
threads and OpenMP) and the possibility of a single programming model that
550
will work well across a wide range of shared and distributed memory
551
platforms.
552
PGAS languages provide a shared memory abstraction with support for locality
553
through the user of distributed data types. The three most mature PGAS
554
languages (UPC, CAF and Titanium) offer a statically partitioned global
555
address space with a static SPMD control model, while languages emerging
556
from the DARPA HPCS program are more dynamic. I will describe these
557
languages as well as our experience using them in both numeric and
558
symbolic applications.""")
559
560
]
561
562
563
def find(name):
564
name = name.lower()
565
ans = None
566
for v in speakers:
567
if name in v.name.lower():
568
if not ans is None:
569
raise RuntimeError, "ambiguous search for '%s'"%name
570
ans = v
571
if ans is None:
572
raise RuntimeError, "Speaker '%s' not found"%name
573
return ans
574
575
576
577
##############
578
579
def html_talks(file='a'):
580
a = open('%s.html'%file,'w')
581
a.write(r"""
582
<html>
583
<head>
584
<title>
585
Interactive Parallel Computation in Support of Research
586
in Algebra, Geometry and Number Theory: Abstracts
587
</title>
588
589
<style>
590
div.box {
591
border:1px solid #004400;
592
padding:10px;
593
margin-left:30px;
594
margin-right:30px;
595
}
596
table {
597
border-bottom:1px solid lightgray;
598
border-top:1px solid lightgray;
599
}
600
601
a:active { color: #ff0000; }
602
a:hover { background-color: #aaffaa}
603
a { text-decoration: none; }
604
605
div.space {
606
padding:50px;
607
margin-top:15px;
608
background-color:#eeeeee;
609
}
610
611
612
h2.top {
613
text-align:center;
614
}
615
616
div.bar {
617
padding:1px;
618
background-color:#999999;
619
border-top: 1px solid black;
620
border-bottom: 1px solid black;
621
margin:2px;
622
}
623
624
</style>
625
626
<body>
627
<h1 align=center>Titles and Abstracts</h1>
628
629
These are the abstracts for all the talks scheduled for <a href="index.html">MSRI Parallel Computation
630
the workshop</a>, listed in
631
alphabetical order. For times, see the <a href="schedule.html">the schedule</a> itself.
632
<br>
633
<hr>
634
""")
635
for s in speakers:
636
a.write(s.html_full())
637
a.write('<br><br><hr>')
638
a.write('</body></html>')
639
a.close()
640
641
def wiki_talks():
642
a = open('%s.txt'%file,'w')
643
a.write(r"""
644
= Titles and Abstracts =
645
These are the abstracts for all the talks scheduled for [:msri07: the workshop], listed in
646
alphabetical order. For times, see the [:msri07/schedule: schedule] itself.
647
648
[[TableOfContents]]
649
650
""")
651
652
for s in speakers:
653
a.write(s.wiki_full())
654
a.write('\n\n')
655
a.close()
656
657
def pdf_abstracts(file='a', verbose=False):
658
a = open('%s.tex'%file,'w')
659
a.write(r"""
660
\documentclass{article}
661
\usepackage{url}
662
\usepackage{fullpage}
663
\title{Titles and Abstracts:\vspace{4ex}\mbox{}\\
664
\Large Interactive Parallel Computation in Support of Research in\\Algebra, Geometry
665
and Number Theory\vspace{4ex}\mbox{}\\
666
\large A Workshop at MSRI Jan 29-Feb 2 organized by\\Burhanuddin, Demmel, Goins, Kaltofen, Perez, Stein, Verrill, and Weening}
667
\begin{document}
668
\maketitle
669
\par\noindent
670
""")
671
for s in speakers:
672
a.write(s.latex_full())
673
a.write('\\mbox{}\\vspace{6ex}\n\n\n\\par\\noindent')
674
a.write('\\end{document}')
675
a.close()
676
if not verbose:
677
z = '1>/dev/null'
678
else:
679
z = ''
680
os.system('pdflatex %s.tex < /dev/null %s'%(file, z))
681
682
########################################################################################
683
684
class Day:
685
def __init__(self, name, theme='', discussion='', invited=[], contributed=[]):
686
self.name = name
687
self.theme = theme
688
self.discussion = discussion
689
self.invited = invited
690
self.contributed = contributed
691
692
def __repr__(self):
693
return self.name
694
695
def html_contrib(self, n):
696
c = self.contributed
697
if n < len(c):
698
if 'Cohn' in c[n].name:
699
return c[n].html_short() + ' (part %s)'%n
700
else:
701
return '(Optional) ' + c[n].html_short()
702
else:
703
return 'Break'
704
705
def latex_contrib(self, n):
706
c = self.contributed
707
if n < len(c):
708
if 'Cohn' in c[n].name:
709
return c[n].latex_short() + ' (part %s)'%n
710
else:
711
return '(Optional) '+ c[n].latex_short()
712
else:
713
return 'Break'
714
715
def html(self):
716
s = """
717
<a name="%s">
718
<table class="ws" width=90%% align=center>
719
<tr><td class='time' width=10%%></td><td class="day" width=80%%><font size=+3><b>%s</b><br><font size=+2><b>Theme: %s</b></font></td></tr>
720
<tr><td class='time'>9:00-10:00</td><td>%s</td></tr>
721
<tr><td class='time'>10:00-10:30</td><td class="break">Tea Break</td></tr>
722
<tr><td class='time'>10:30-11:30</td><td>%s</td></tr>
723
<tr><td class='time'>11:30-12:30</td><td>%s</td></tr>
724
<tr><td class='time'>12:30-1:30</td><td class="break">Lunch</td></tr>
725
<tr><td class='time'>1:30-2:00</td><td>%s</td></tr>
726
<tr><td class='time'>2:00-2:30</td><td>%s</td></tr>
727
<tr><td class='time'>2:30-3:30</td><td class="discuss"><b>Discussion:</b> %s</td></tr>
728
"""%(
729
self.name.split()[0].strip(',').lower(),
730
self.name, self.theme,
731
self.invited[0].html_short(),
732
self.invited[1].html_short(),
733
self.invited[2].html_short(),
734
self.html_contrib(0),
735
self.html_contrib(1),
736
self.discussion)
737
if self.name != 'Friday, Feb 2':
738
s += """
739
<tr><td class='time'>3:30-4:00</td><td class="break">Tea Break</td></tr>
740
<tr><td class='time'>4:00-5:30</td><td>Working Sessions</td></tr>
741
<tr><td class='time'>6:00-8:00</td><td class="break">Dinner</td></tr>
742
<tr><td class='time'>8:00-10:00</td><td class="break">Coffee Shops...</td></tr>
743
"""
744
s += """
745
</table>
746
"""
747
return s
748
749
def latex(self):
750
s = """
751
{\\Large \\bf %s}\\vspace{1ex}
752
753
\\begin{tabular}{|l|l|}\\hline
754
& \\begin{minipage}{0.7\\textwidth}Theme: %s\\end{minipage} \\\\ \\hline
755
9:00--10:00 & \\begin{minipage}{0.7\\textwidth}%s\\end{minipage} \\\\
756
10:00--10:30 & \\begin{minipage}{0.7\\textwidth}Tea Break\\end{minipage} \\\\
757
10:30--11:30 & \\begin{minipage}{0.7\\textwidth}%s\\end{minipage} \\\\
758
11:30--12:30 & \\begin{minipage}{0.7\\textwidth}%s\\end{minipage} \\\\ \\hline
759
12:30--1:30 & \\begin{minipage}{0.7\\textwidth}Lunch\\end{minipage} \\\\
760
1:30--2:00 & \\begin{minipage}{0.7\\textwidth}%s\\end{minipage} \\\\
761
2:00--2:30 & \\begin{minipage}{0.7\\textwidth}%s\\end{minipage} \\\\ \\hline
762
2:30--3:30 & \\begin{minipage}{0.7\\textwidth}Discussion: %s\\end{minipage} \\\\
763
"""%(
764
self.name, self.theme,
765
self.invited[0].latex_short(),
766
self.invited[1].latex_short(),
767
self.invited[2].latex_short(),
768
self.latex_contrib(0),
769
self.latex_contrib(1),
770
self.discussion
771
)
772
if self.name != 'Friday, Feb 2':
773
s += """
774
3:30--4:00 & \\begin{minipage}{0.7\\textwidth}Tea Break\\end{minipage} \\\\
775
4:00--5:30 & \\begin{minipage}{0.7\\textwidth}Working Sessions\\end{minipage} \\\\
776
6:00--8:00 & \\begin{minipage}{0.7\\textwidth}Dinner\\end{minipage} \\\\
777
8:00--10:00 & \\begin{minipage}{0.7\\textwidth}Coffee Shops...\\end{minipage} \\\\ \\hline
778
"""
779
s += '\\end{tabular}'
780
return s
781
782
days = [\
783
Day('Monday, Jan 29',
784
'What do we want and what can we expect from applying parallel techniques to pure mathematics research tools?',
785
"""Parallel methods for mathematics software for doing algebra, geometry
786
and number theory -- What can we expect? What are the right problems to attack first
787
and get the most for our work?
788
""",
789
[find('pernet'),
790
find('granger'),
791
find('roch')],
792
[find('cohn'), find('cohn')]),
793
794
Day('Tuesday, Jan 30',
795
'Algebra',
796
'Parallel methods for algebra (commutative algebra, linear algebra, group theory).',
797
[find('yelick'), find('hida'), find('noel')],
798
[find('Leykin'), find('tonchev')]
799
),
800
801
Day('Wednesday, Jan 31',
802
'Number Theory',
803
"Parallel methods for number theory.",
804
[find('martin'), find('hart'), find('qiang')],
805
[find('bradshaw'), find('kotsireas')]
806
),
807
808
Day('Thursday, Feb 1',
809
'Geometry',
810
'Parallel methods for geometry',
811
[find('verschelde'), find('moreno'), find('bailey')],
812
[find('wolf'), find('neun')]),
813
814
Day('Friday, Feb 2',
815
'Large-Scale Parallel Computation',
816
'Wrap-up session',
817
[find('harrison'), find('cooperman'), find('edelman')],
818
[find('khan')])
819
]
820
821
822
def html_sched(file='a'):
823
a = open('%s.html'%file,'w')
824
a.write(r"""
825
<html>
826
<head>
827
<title>
828
Interactive Parallel Computation in Support of Research
829
in Algebra, Geometry and Number Theory: Schedule
830
</title>
831
832
<style>
833
div.box {
834
border:1px solid #004400;
835
padding:10px;
836
margin-left:30px;
837
margin-right:30px;
838
}
839
840
table.ws {
841
border-width: 1px 1px 1px 1px;
842
border-spacing: 0px;
843
border-style: solid solid solid solid ;
844
border-color: gray gray gray gray;
845
border-collapse: separate;
846
background-color: #333355;
847
}
848
table.ws th {
849
border-width: 1px 1px 1px 1px;
850
padding: 1px 1px 1px 1px;
851
border-style: solid solid solid solid ;
852
border-color: gray gray gray gray;
853
background-color: white;
854
-moz-border-radius: 0px 0px 0px 0px;
855
padding:10px;
856
}
857
table.ws td {
858
border-width: 1px 1px 1px 1px;
859
padding: 1px 1px 1px 1px;
860
border-style: solid solid solid solid ;
861
border-color: gray gray gray gray;
862
background-color: white;
863
-moz-border-radius: 0px 0px 0px 0px;
864
padding:10px;
865
}
866
table.ws td.break {
867
border-width: 1px 1px 1px 1px;
868
padding: 1px 1px 1px 1px;
869
border-style: solid solid solid solid ;
870
border-color: gray gray gray gray;
871
background-color: #80ff80;
872
-moz-border-radius: 0px 0px 0px 0px;
873
padding:10px;
874
}
875
876
table.ws td.day {
877
border-width: 1px 1px 1px 1px;
878
padding: 1px 1px 1px 1px;
879
border-style: solid solid solid solid ;
880
border-color: gray gray gray gray;
881
background-color: #e0e0ff;
882
-moz-border-radius: 0px 0px 0px 0px;
883
padding:10px;
884
}
885
886
table.ws td.discuss {
887
border-width: 1px 1px 1px 1px;
888
padding: 1px 1px 1px 1px;
889
border-style: solid solid solid solid ;
890
border-color: gray gray gray gray;
891
background-color: #e0ffe0;
892
-moz-border-radius: 0px 0px 0px 0px;
893
padding:10px;
894
}
895
896
table.ws td.time {
897
border-width: 1px 1px 1px 1px;
898
padding: 1px 1px 1px 1px;
899
border-style: solid solid solid solid ;
900
border-color: gray gray gray gray;
901
background-color: #ffffe0;
902
-moz-border-radius: 0px 0px 0px 0px;
903
padding:10px;
904
}
905
906
a:active { color: #ff0000; }
907
a:hover { background-color: #aaffaa}
908
a { text-decoration: none; }
909
910
div.space {
911
padding:50px;
912
margin-top:15px;
913
background-color:#eeeeee;
914
}
915
916
917
h2.top {
918
text-align:center;
919
}
920
921
div.bar {
922
padding:1px;
923
background-color:#999999;
924
border-top: 1px solid black;
925
border-bottom: 1px solid black;
926
margin:2px;
927
}
928
929
</style>
930
931
<body>
932
<h1 align=center>Schedule and <a href="#abstracts">Abstracts</a></h1>
933
<h3>
934
This is the schedule of talks and list of abstracts for this <a href="index.html">MSRI Parallel Computation
935
workshop</a>. There is also <a href="schedule.pdf">a PDF schedule</a> and
936
<a href="abstracts.pdf">a PDF list of abstracts</a>.
937
</h3>
938
<h3 align=center>
939
<a href="#monday">Monday</a> | <a href="#tuesday">Tuesday</a> |
940
<a href="#wednesday">Wednesday</a> |
941
<a href="#thursday">Thursday</a> |
942
<a href="#friday">Friday</a>
943
</h3>
944
<div class='bar'></div>
945
""")
946
947
for d in days:
948
a.write(d.html())
949
a.write("<br><div class='bar'></div><br>")
950
951
a.write('<a name="abstracts"><h1>Abstracts</h1>')
952
for s in speakers:
953
a.write(s.html_full())
954
a.write('<br><br><hr>')
955
956
a.write('</body></html>')
957
958
a.close()
959
960
961
962
def pdf_sched(file='a', verbose=False):
963
a = open('%s.tex'%file,'w')
964
a.write(r"""
965
\documentclass{article}
966
\usepackage{url}
967
\usepackage{fullpage}
968
\title{Schedule: Jan 29 -- Feb 2, 2007\vspace{3ex}\mbox{}\\
969
\Large MSRI: Interactive Parallel Computation in Support of Research in\\Algebra, Geometry
970
and Number Theory}
971
\date{}
972
\begin{document}
973
\maketitle
974
\vspace{-3ex}
975
976
\mbox{}\par\noindent
977
\begin{center}
978
""".strip())
979
for d in days:
980
a.write(d.latex())
981
a.write('\\mbox{}\\vspace{4ex}\n\n\n\\par\\noindent')
982
a.write('\\end{center}')
983
a.write('\\end{document}')
984
a.close()
985
if not verbose:
986
z = '1>/dev/null'
987
else:
988
z = ''
989
os.system('pdflatex %s.tex < /dev/null %s'%(file, z))
990
991
992
def gen():
993
dir='/home/was/conferences/2007-msri-parallel/'
994
pdf_sched(file='schedule', verbose=True)
995
pdf_abstracts(file='abstracts', verbose=True)
996
html_sched(file='schedule')
997
os.system('cp -v *.pdf *.html %s/'%dir)
998