Serveur d'exploration sur la recherche en informatique en Lorraine

Attention, ce site est en cours de développement !
Attention, site généré par des moyens informatiques à partir de corpus bruts.
Les informations ne sont donc pas validées.

Experience with a clustered parallel reduction machine

Identifieur interne : 001F28 ( Istex/Corpus ); précédent : 001F27; suivant : 001F29

Experience with a clustered parallel reduction machine

Auteurs : M. Beemster ; P. H Hartel ; L. O Hertzberger ; R. F. H Hofman ; K. G Langendoen ; L. L Li ; R. Milikowski ; Wg Vree ; H. P Barendregt ; J. C Mulder

Source :

RBID : ISTEX:86FDB730C5EA7FC7EDFA7D39BC30F5C066F72F62

English descriptors

Abstract

Abstract: A clustered architecture has been designed to exploit divide and conquer parallelism in functional programs. The programming methodology developed for the machine is based on explicit annotations and program transformations. It has been successfully applied to a number of algorithms resulting in a benchmark of small and medium size parallel functional programs. Sophisticated compilation techniques are used such as strictness analysis on non-flat domains and RISC and VLIW code generation. Parallel jobs are distributed by an efficient hierarchical scheduler. A special processor for graph reduction has been designed as a basic block for the machine. A prototype of a single cluster machine has been constructed with stock hardware. This paper describes the experience with the project and its current state.

Url:
DOI: 10.1016/0167-739X(93)90011-D

Links to Exploration step

ISTEX:86FDB730C5EA7FC7EDFA7D39BC30F5C066F72F62

Le document en format XML

<record>
<TEI wicri:istexFullTextTei="biblStruct">
<teiHeader>
<fileDesc>
<titleStmt>
<title>Experience with a clustered parallel reduction machine</title>
<author>
<name sortKey="Beemster, M" sort="Beemster, M" uniqKey="Beemster M" first="M" last="Beemster">M. Beemster</name>
<affiliation>
<mods:affiliation>Department of Computer Systems, University of Amsterdam, Kruislaan 403, 1098 SJ Amsterdam, The Netherlands</mods:affiliation>
</affiliation>
</author>
<author>
<name sortKey="Hartel, P H" sort="Hartel, P H" uniqKey="Hartel P" first="P. H" last="Hartel">P. H Hartel</name>
<affiliation>
<mods:affiliation>Correspondence to: P.H. Hartel, Dept. of Computer Systems, University of Amsterdam, Kruislaan 403, 1098 SJ Amsterdam, The Netherlands.</mods:affiliation>
</affiliation>
<affiliation>
<mods:affiliation>Department of Computer Systems, University of Amsterdam, Kruislaan 403, 1098 SJ Amsterdam, The Netherlands</mods:affiliation>
</affiliation>
</author>
<author>
<name sortKey="Hertzberger, L O" sort="Hertzberger, L O" uniqKey="Hertzberger L" first="L. O" last="Hertzberger">L. O Hertzberger</name>
<affiliation>
<mods:affiliation>Department of Computer Systems, University of Amsterdam, Kruislaan 403, 1098 SJ Amsterdam, The Netherlands</mods:affiliation>
</affiliation>
</author>
<author>
<name sortKey="Hofman, R F H" sort="Hofman, R F H" uniqKey="Hofman R" first="R. F. H" last="Hofman">R. F. H Hofman</name>
<affiliation>
<mods:affiliation>Department of Computer Systems, University of Amsterdam, Kruislaan 403, 1098 SJ Amsterdam, The Netherlands</mods:affiliation>
</affiliation>
</author>
<author>
<name sortKey="Langendoen, K G" sort="Langendoen, K G" uniqKey="Langendoen K" first="K. G" last="Langendoen">K. G Langendoen</name>
<affiliation>
<mods:affiliation>Department of Computer Systems, University of Amsterdam, Kruislaan 403, 1098 SJ Amsterdam, The Netherlands</mods:affiliation>
</affiliation>
</author>
<author>
<name sortKey="Li, L L" sort="Li, L L" uniqKey="Li L" first="L. L" last="Li">L. L Li</name>
<affiliation>
<mods:affiliation>ECRC, Arabellastrasse 17, D-8000 Munich 81, Germany</mods:affiliation>
</affiliation>
</author>
<author>
<name sortKey="Milikowski, R" sort="Milikowski, R" uniqKey="Milikowski R" first="R" last="Milikowski">R. Milikowski</name>
<affiliation>
<mods:affiliation>Department of Computer Systems, University of Amsterdam, Kruislaan 403, 1098 SJ Amsterdam, The Netherlands</mods:affiliation>
</affiliation>
</author>
<author>
<name sortKey="Vree, Wg" sort="Vree, Wg" uniqKey="Vree W" first="Wg" last="Vree">Wg Vree</name>
<affiliation>
<mods:affiliation>Department of Computer Systems, University of Amsterdam, Kruislaan 403, 1098 SJ Amsterdam, The Netherlands</mods:affiliation>
</affiliation>
</author>
<author>
<name sortKey="Barendregt, H P" sort="Barendregt, H P" uniqKey="Barendregt H" first="H. P" last="Barendregt">H. P Barendregt</name>
<affiliation>
<mods:affiliation>Department of Computer Science, University of Nijmegen, Toernooiveld 1, 6252 ED Nijmegen, The Netherlands</mods:affiliation>
</affiliation>
</author>
<author>
<name sortKey="Mulder, J C" sort="Mulder, J C" uniqKey="Mulder J" first="J. C" last="Mulder">J. C Mulder</name>
<affiliation>
<mods:affiliation>Department of Computer Science, University of Nijmegen, Toernooiveld 1, 6252 ED Nijmegen, The Netherlands</mods:affiliation>
</affiliation>
</author>
</titleStmt>
<publicationStmt>
<idno type="wicri:source">ISTEX</idno>
<idno type="RBID">ISTEX:86FDB730C5EA7FC7EDFA7D39BC30F5C066F72F62</idno>
<date when="1993" year="1993">1993</date>
<idno type="doi">10.1016/0167-739X(93)90011-D</idno>
<idno type="url">https://api.istex.fr/ark:/67375/6H6-V1WZB2BM-2/fulltext.pdf</idno>
<idno type="wicri:Area/Istex/Corpus">001F28</idno>
<idno type="wicri:explorRef" wicri:stream="Istex" wicri:step="Corpus" wicri:corpus="ISTEX">001F28</idno>
</publicationStmt>
<sourceDesc>
<biblStruct>
<analytic>
<title level="a">Experience with a clustered parallel reduction machine</title>
<author>
<name sortKey="Beemster, M" sort="Beemster, M" uniqKey="Beemster M" first="M" last="Beemster">M. Beemster</name>
<affiliation>
<mods:affiliation>Department of Computer Systems, University of Amsterdam, Kruislaan 403, 1098 SJ Amsterdam, The Netherlands</mods:affiliation>
</affiliation>
</author>
<author>
<name sortKey="Hartel, P H" sort="Hartel, P H" uniqKey="Hartel P" first="P. H" last="Hartel">P. H Hartel</name>
<affiliation>
<mods:affiliation>Correspondence to: P.H. Hartel, Dept. of Computer Systems, University of Amsterdam, Kruislaan 403, 1098 SJ Amsterdam, The Netherlands.</mods:affiliation>
</affiliation>
<affiliation>
<mods:affiliation>Department of Computer Systems, University of Amsterdam, Kruislaan 403, 1098 SJ Amsterdam, The Netherlands</mods:affiliation>
</affiliation>
</author>
<author>
<name sortKey="Hertzberger, L O" sort="Hertzberger, L O" uniqKey="Hertzberger L" first="L. O" last="Hertzberger">L. O Hertzberger</name>
<affiliation>
<mods:affiliation>Department of Computer Systems, University of Amsterdam, Kruislaan 403, 1098 SJ Amsterdam, The Netherlands</mods:affiliation>
</affiliation>
</author>
<author>
<name sortKey="Hofman, R F H" sort="Hofman, R F H" uniqKey="Hofman R" first="R. F. H" last="Hofman">R. F. H Hofman</name>
<affiliation>
<mods:affiliation>Department of Computer Systems, University of Amsterdam, Kruislaan 403, 1098 SJ Amsterdam, The Netherlands</mods:affiliation>
</affiliation>
</author>
<author>
<name sortKey="Langendoen, K G" sort="Langendoen, K G" uniqKey="Langendoen K" first="K. G" last="Langendoen">K. G Langendoen</name>
<affiliation>
<mods:affiliation>Department of Computer Systems, University of Amsterdam, Kruislaan 403, 1098 SJ Amsterdam, The Netherlands</mods:affiliation>
</affiliation>
</author>
<author>
<name sortKey="Li, L L" sort="Li, L L" uniqKey="Li L" first="L. L" last="Li">L. L Li</name>
<affiliation>
<mods:affiliation>ECRC, Arabellastrasse 17, D-8000 Munich 81, Germany</mods:affiliation>
</affiliation>
</author>
<author>
<name sortKey="Milikowski, R" sort="Milikowski, R" uniqKey="Milikowski R" first="R" last="Milikowski">R. Milikowski</name>
<affiliation>
<mods:affiliation>Department of Computer Systems, University of Amsterdam, Kruislaan 403, 1098 SJ Amsterdam, The Netherlands</mods:affiliation>
</affiliation>
</author>
<author>
<name sortKey="Vree, Wg" sort="Vree, Wg" uniqKey="Vree W" first="Wg" last="Vree">Wg Vree</name>
<affiliation>
<mods:affiliation>Department of Computer Systems, University of Amsterdam, Kruislaan 403, 1098 SJ Amsterdam, The Netherlands</mods:affiliation>
</affiliation>
</author>
<author>
<name sortKey="Barendregt, H P" sort="Barendregt, H P" uniqKey="Barendregt H" first="H. P" last="Barendregt">H. P Barendregt</name>
<affiliation>
<mods:affiliation>Department of Computer Science, University of Nijmegen, Toernooiveld 1, 6252 ED Nijmegen, The Netherlands</mods:affiliation>
</affiliation>
</author>
<author>
<name sortKey="Mulder, J C" sort="Mulder, J C" uniqKey="Mulder J" first="J. C" last="Mulder">J. C Mulder</name>
<affiliation>
<mods:affiliation>Department of Computer Science, University of Nijmegen, Toernooiveld 1, 6252 ED Nijmegen, The Netherlands</mods:affiliation>
</affiliation>
</author>
</analytic>
<monogr></monogr>
<series>
<title level="j">Future Generation Computer Systems</title>
<title level="j" type="abbrev">FUTURE</title>
<idno type="ISSN">0167-739X</idno>
<imprint>
<publisher>ELSEVIER</publisher>
<date type="published" when="1993">1993</date>
<biblScope unit="volume">9</biblScope>
<biblScope unit="issue">3</biblScope>
<biblScope unit="page" from="175">175</biblScope>
<biblScope unit="page" to="200">200</biblScope>
</imprint>
<idno type="ISSN">0167-739X</idno>
</series>
</biblStruct>
</sourceDesc>
<seriesStmt>
<idno type="ISSN">0167-739X</idno>
</seriesStmt>
</fileDesc>
<profileDesc>
<textClass>
<keywords scheme="Teeft" xml:lang="en">
<term>Abstract interpretation</term>
<term>Address calculations</term>
<term>Algorithm</term>
<term>Aliasing analysis</term>
<term>Amsterdam</term>
<term>Angular brackets</term>
<term>Annotation</term>
<term>Architecture</term>
<term>Average parallelism</term>
<term>Basic blocks</term>
<term>Beemster</term>
<term>Benchmark</term>
<term>Bracket</term>
<term>Catholic university</term>
<term>Chalmers univ</term>
<term>Changsha institute</term>
<term>Coarse grain</term>
<term>Coarse grain parallelism</term>
<term>Code generation</term>
<term>Code generation techniques</term>
<term>Code generator</term>
<term>Code generators</term>
<term>Code sequences</term>
<term>Comp</term>
<term>Compilation techniques</term>
<term>Compiler</term>
<term>Compiler construction</term>
<term>Computational demand</term>
<term>Computer architecture</term>
<term>Computer architecture conf</term>
<term>Computer science</term>
<term>Computer systems</term>
<term>Conf</term>
<term>Control integrity problem</term>
<term>Cprm</term>
<term>Current heap pointer</term>
<term>Cyclic</term>
<term>Cyclic fashion</term>
<term>Data structure</term>
<term>Data values</term>
<term>Declarative languages</term>
<term>Dependency</term>
<term>Dependency analysis</term>
<term>Dependency arcs</term>
<term>Dependency graph</term>
<term>Dept</term>
<term>Direct subdomains</term>
<term>Dutch waterboard</term>
<term>Efficient code</term>
<term>Efficient compilation</term>
<term>Efficient implementation</term>
<term>Efficient runtime support</term>
<term>Elsevier science publishers</term>
<term>Equivalent program</term>
<term>Exclusive access</term>
<term>Explicit annotations</term>
<term>Extra code</term>
<term>Final version</term>
<term>Fine grain parallelism</term>
<term>First argument</term>
<term>First elimination</term>
<term>Flow graphs</term>
<term>Fourier</term>
<term>Free university</term>
<term>Function bodies</term>
<term>Functional language</term>
<term>Functional languages</term>
<term>Functional program</term>
<term>Functional programming</term>
<term>Functional programming languages</term>
<term>Functional programs</term>
<term>Functional units</term>
<term>Garbage collector</term>
<term>Global</term>
<term>Global buses</term>
<term>Grain parallelism</term>
<term>Grain size</term>
<term>Grain size transformation</term>
<term>Graph reduction</term>
<term>Hartel</term>
<term>Heap pointer</term>
<term>Heap unit</term>
<term>Heap units</term>
<term>Hierarchical</term>
<term>Ieee trans</term>
<term>Imperative languages</term>
<term>Imperative programs</term>
<term>Inherent parallelism</term>
<term>Initial scheduler</term>
<term>Initial state</term>
<term>Input data</term>
<term>Input elements</term>
<term>Input language</term>
<term>Input lists</term>
<term>Instruction scheduler</term>
<term>Instruction scheduling</term>
<term>Intra cluster runtime support system</term>
<term>Koala</term>
<term>Koala code</term>
<term>Lambda</term>
<term>Lambda calculus</term>
<term>Langendoen</term>
<term>Languages europe</term>
<term>Lazy evaluation mechanism</term>
<term>Level optimisations</term>
<term>Library functions</term>
<term>Linear domain</term>
<term>Linear equations</term>
<term>List scheduling</term>
<term>Lncs</term>
<term>Lncs eindhoven</term>
<term>Lncs veldhoven</term>
<term>Machine cycle</term>
<term>Machine cycles</term>
<term>Macro</term>
<term>Maximum number</term>
<term>Medium grain parallelism</term>
<term>Medium size</term>
<term>Memory machine</term>
<term>Memory management</term>
<term>Memory manager</term>
<term>Memory references</term>
<term>Memory units</term>
<term>Methodology</term>
<term>Netherlands</term>
<term>Next output</term>
<term>Next section</term>
<term>Nijmegen</term>
<term>Node</term>
<term>Normal form</term>
<term>Normal order reduction</term>
<term>Optimisation</term>
<term>Other jobs</term>
<term>Output language</term>
<term>Parallel applications</term>
<term>Parallel architecture</term>
<term>Parallel architectures</term>
<term>Parallel computations</term>
<term>Parallel evaluation</term>
<term>Parallel execution</term>
<term>Parallel grains</term>
<term>Parallel graph reduction</term>
<term>Parallel jobs</term>
<term>Parallel phases</term>
<term>Parallel processing</term>
<term>Parallel reduction machine</term>
<term>Parallel reduction machines</term>
<term>Parallel reduction strategy</term>
<term>Parallel systems</term>
<term>Parallelism</term>
<term>Parent tasks</term>
<term>Performance loss</term>
<term>Peyton jones</term>
<term>Plasmeijer</term>
<term>Pointer</term>
<term>Predictable number</term>
<term>Primitive operations</term>
<term>Private heap</term>
<term>Process control</term>
<term>Process network</term>
<term>Process networks</term>
<term>Processor</term>
<term>Processor stack</term>
<term>Program analyses</term>
<term>Program analysis</term>
<term>Program transformation</term>
<term>Program transformations</term>
<term>Programmer</term>
<term>Programming</term>
<term>Programming languages</term>
<term>Programming methodology</term>
<term>Programming methodology group report</term>
<term>Reduction machine</term>
<term>Reduction machines</term>
<term>Referential</term>
<term>Referential transparency</term>
<term>Research interests</term>
<term>Research software</term>
<term>Risc</term>
<term>Risc processors</term>
<term>Runtime</term>
<term>Runtime support system</term>
<term>Same instruction</term>
<term>Same time</term>
<term>Sandwich reduction strategy</term>
<term>Sandwich strategy</term>
<term>Sasl program</term>
<term>Sasl programs</term>
<term>Scalable</term>
<term>Scheduler</term>
<term>Scheduler tree</term>
<term>Scheduling</term>
<term>Scheduling algorithm</term>
<term>Second argument</term>
<term>Second elimination</term>
<term>Senior lecturer</term>
<term>Sequential</term>
<term>Sequential part</term>
<term>Sequential version</term>
<term>Side effects</term>
<term>Sigplan notices</term>
<term>Simulation</term>
<term>Simulation studies</term>
<term>Single address space</term>
<term>Single cluster machine</term>
<term>Single instruction</term>
<term>Single vliw instruction</term>
<term>Software</term>
<term>Speedup</term>
<term>Spineless tagless</term>
<term>Spineless tagless machine</term>
<term>Stack</term>
<term>Stack code</term>
<term>Stack pointer</term>
<term>Stack units</term>
<term>Standard transformations</term>
<term>Statically type</term>
<term>Stock hardware</term>
<term>Stoffel</term>
<term>Stoffel compiler</term>
<term>Strictness</term>
<term>Strictness analysis</term>
<term>Subgraph</term>
<term>Synchronous process networks</term>
<term>Synthesis techniques</term>
<term>Systems architecture</term>
<term>Technical report dept</term>
<term>Time support system</term>
<term>Transformational methods</term>
<term>Transparency</term>
<term>Tree structure</term>
<term>Univ</term>
<term>Unlimited number</term>
<term>Untyped</term>
<term>Virtual registers</term>
<term>Vliw</term>
<term>Vliw architectures</term>
<term>Vliw code</term>
<term>Vliw instruction</term>
<term>Vliw machine</term>
<term>Vliw processor</term>
<term>Vliw processors</term>
<term>Vree</term>
</keywords>
</textClass>
<langUsage>
<language ident="en">en</language>
</langUsage>
</profileDesc>
</teiHeader>
<front>
<div type="abstract" xml:lang="en">Abstract: A clustered architecture has been designed to exploit divide and conquer parallelism in functional programs. The programming methodology developed for the machine is based on explicit annotations and program transformations. It has been successfully applied to a number of algorithms resulting in a benchmark of small and medium size parallel functional programs. Sophisticated compilation techniques are used such as strictness analysis on non-flat domains and RISC and VLIW code generation. Parallel jobs are distributed by an efficient hierarchical scheduler. A special processor for graph reduction has been designed as a basic block for the machine. A prototype of a single cluster machine has been constructed with stock hardware. This paper describes the experience with the project and its current state.</div>
</front>
</TEI>
<istex>
<corpusName>elsevier</corpusName>
<keywords>
<teeft>
<json:string>vliw</json:string>
<json:string>scheduler</json:string>
<json:string>univ</json:string>
<json:string>comp</json:string>
<json:string>functional languages</json:string>
<json:string>lncs</json:string>
<json:string>computer science</json:string>
<json:string>sequential</json:string>
<json:string>algorithm</json:string>
<json:string>conf</json:string>
<json:string>benchmark</json:string>
<json:string>beemster</json:string>
<json:string>optimisation</json:string>
<json:string>vree</json:string>
<json:string>runtime</json:string>
<json:string>cprm</json:string>
<json:string>functional programming languages</json:string>
<json:string>annotation</json:string>
<json:string>hartel</json:string>
<json:string>code generator</json:string>
<json:string>strictness</json:string>
<json:string>subgraph</json:string>
<json:string>parallelism</json:string>
<json:string>stoffel</json:string>
<json:string>nijmegen</json:string>
<json:string>computer architecture</json:string>
<json:string>functional programs</json:string>
<json:string>functional programming</json:string>
<json:string>fourier</json:string>
<json:string>node</json:string>
<json:string>functional language</json:string>
<json:string>koala</json:string>
<json:string>graph reduction</json:string>
<json:string>langendoen</json:string>
<json:string>hierarchical</json:string>
<json:string>grain size</json:string>
<json:string>scalable</json:string>
<json:string>memory units</json:string>
<json:string>technical report dept</json:string>
<json:string>instruction scheduling</json:string>
<json:string>sandwich strategy</json:string>
<json:string>cyclic</json:string>
<json:string>methodology</json:string>
<json:string>processor</json:string>
<json:string>plasmeijer</json:string>
<json:string>parallel architectures</json:string>
<json:string>vliw processor</json:string>
<json:string>research interests</json:string>
<json:string>programming methodology</json:string>
<json:string>strictness analysis</json:string>
<json:string>macro</json:string>
<json:string>risc</json:string>
<json:string>lambda</json:string>
<json:string>referential</json:string>
<json:string>heap units</json:string>
<json:string>software</json:string>
<json:string>untyped</json:string>
<json:string>memory machine</json:string>
<json:string>languages europe</json:string>
<json:string>program transformations</json:string>
<json:string>stack units</json:string>
<json:string>imperative languages</json:string>
<json:string>referential transparency</json:string>
<json:string>scheduling</json:string>
<json:string>amsterdam</json:string>
<json:string>compiler</json:string>
<json:string>code generation techniques</json:string>
<json:string>functional program</json:string>
<json:string>lambda calculus</json:string>
<json:string>peyton jones</json:string>
<json:string>instruction scheduler</json:string>
<json:string>programming</json:string>
<json:string>code generation</json:string>
<json:string>process networks</json:string>
<json:string>computer systems</json:string>
<json:string>reduction machine</json:string>
<json:string>parallel evaluation</json:string>
<json:string>sigplan notices</json:string>
<json:string>heap pointer</json:string>
<json:string>first argument</json:string>
<json:string>stoffel compiler</json:string>
<json:string>angular brackets</json:string>
<json:string>vliw architectures</json:string>
<json:string>global buses</json:string>
<json:string>declarative languages</json:string>
<json:string>free university</json:string>
<json:string>average parallelism</json:string>
<json:string>compilation techniques</json:string>
<json:string>parallel jobs</json:string>
<json:string>fine grain parallelism</json:string>
<json:string>parallel graph reduction</json:string>
<json:string>aliasing analysis</json:string>
<json:string>speedup</json:string>
<json:string>bracket</json:string>
<json:string>dependency analysis</json:string>
<json:string>same time</json:string>
<json:string>stack pointer</json:string>
<json:string>basic blocks</json:string>
<json:string>dependency graph</json:string>
<json:string>single instruction</json:string>
<json:string>lncs veldhoven</json:string>
<json:string>garbage collector</json:string>
<json:string>parallel grains</json:string>
<json:string>runtime support system</json:string>
<json:string>computational demand</json:string>
<json:string>library functions</json:string>
<json:string>memory manager</json:string>
<json:string>tree structure</json:string>
<json:string>processor stack</json:string>
<json:string>parent tasks</json:string>
<json:string>koala code</json:string>
<json:string>unlimited number</json:string>
<json:string>efficient code</json:string>
<json:string>input language</json:string>
<json:string>ieee trans</json:string>
<json:string>functional units</json:string>
<json:string>machine cycle</json:string>
<json:string>lncs eindhoven</json:string>
<json:string>extra code</json:string>
<json:string>second argument</json:string>
<json:string>grain size transformation</json:string>
<json:string>medium size</json:string>
<json:string>process network</json:string>
<json:string>next section</json:string>
<json:string>vliw processors</json:string>
<json:string>program transformation</json:string>
<json:string>synchronous process networks</json:string>
<json:string>parallel reduction machines</json:string>
<json:string>compiler construction</json:string>
<json:string>coarse grain</json:string>
<json:string>heap unit</json:string>
<json:string>architecture</json:string>
<json:string>dependency</json:string>
<json:string>stack</json:string>
<json:string>pointer</json:string>
<json:string>programmer</json:string>
<json:string>netherlands</json:string>
<json:string>global</json:string>
<json:string>efficient runtime support</json:string>
<json:string>linear domain</json:string>
<json:string>synthesis techniques</json:string>
<json:string>coarse grain parallelism</json:string>
<json:string>parallel systems</json:string>
<json:string>output language</json:string>
<json:string>data values</json:string>
<json:string>other jobs</json:string>
<json:string>single cluster machine</json:string>
<json:string>parallel execution</json:string>
<json:string>lazy evaluation mechanism</json:string>
<json:string>primitive operations</json:string>
<json:string>parallel reduction strategy</json:string>
<json:string>sandwich reduction strategy</json:string>
<json:string>stack code</json:string>
<json:string>exclusive access</json:string>
<json:string>vliw machine</json:string>
<json:string>stock hardware</json:string>
<json:string>normal form</json:string>
<json:string>equivalent program</json:string>
<json:string>list scheduling</json:string>
<json:string>function bodies</json:string>
<json:string>same instruction</json:string>
<json:string>normal order reduction</json:string>
<json:string>parallel applications</json:string>
<json:string>memory references</json:string>
<json:string>spineless tagless</json:string>
<json:string>vliw code</json:string>
<json:string>spineless tagless machine</json:string>
<json:string>risc processors</json:string>
<json:string>parallel reduction machine</json:string>
<json:string>level optimisations</json:string>
<json:string>code sequences</json:string>
<json:string>virtual registers</json:string>
<json:string>dependency arcs</json:string>
<json:string>input elements</json:string>
<json:string>predictable number</json:string>
<json:string>parallel phases</json:string>
<json:string>time support system</json:string>
<json:string>code generators</json:string>
<json:string>efficient implementation</json:string>
<json:string>scheduling algorithm</json:string>
<json:string>control integrity problem</json:string>
<json:string>scheduler tree</json:string>
<json:string>initial scheduler</json:string>
<json:string>direct subdomains</json:string>
<json:string>inherent parallelism</json:string>
<json:string>changsha institute</json:string>
<json:string>grain parallelism</json:string>
<json:string>simulation studies</json:string>
<json:string>performance loss</json:string>
<json:string>intra cluster runtime support system</json:string>
<json:string>standard transformations</json:string>
<json:string>imperative programs</json:string>
<json:string>private heap</json:string>
<json:string>explicit annotations</json:string>
<json:string>research software</json:string>
<json:string>systems architecture</json:string>
<json:string>final version</json:string>
<json:string>data structure</json:string>
<json:string>parallel architecture</json:string>
<json:string>input data</json:string>
<json:string>linear equations</json:string>
<json:string>single vliw instruction</json:string>
<json:string>vliw instruction</json:string>
<json:string>address calculations</json:string>
<json:string>first elimination</json:string>
<json:string>current heap pointer</json:string>
<json:string>single address space</json:string>
<json:string>machine cycles</json:string>
<json:string>sequential part</json:string>
<json:string>maximum number</json:string>
<json:string>second elimination</json:string>
<json:string>programming methodology group report</json:string>
<json:string>medium grain parallelism</json:string>
<json:string>parallel computations</json:string>
<json:string>chalmers univ</json:string>
<json:string>transformational methods</json:string>
<json:string>abstract interpretation</json:string>
<json:string>sequential version</json:string>
<json:string>computer architecture conf</json:string>
<json:string>process control</json:string>
<json:string>next output</json:string>
<json:string>cyclic fashion</json:string>
<json:string>initial state</json:string>
<json:string>input lists</json:string>
<json:string>programming languages</json:string>
<json:string>parallel processing</json:string>
<json:string>side effects</json:string>
<json:string>efficient compilation</json:string>
<json:string>elsevier science publishers</json:string>
<json:string>sasl programs</json:string>
<json:string>program analysis</json:string>
<json:string>statically type</json:string>
<json:string>sasl program</json:string>
<json:string>memory management</json:string>
<json:string>program analyses</json:string>
<json:string>flow graphs</json:string>
<json:string>senior lecturer</json:string>
<json:string>catholic university</json:string>
<json:string>reduction machines</json:string>
<json:string>dutch waterboard</json:string>
<json:string>dept</json:string>
<json:string>simulation</json:string>
<json:string>transparency</json:string>
</teeft>
</keywords>
<author>
<json:item>
<name>M Beemster</name>
<affiliations>
<json:string>Department of Computer Systems, University of Amsterdam, Kruislaan 403, 1098 SJ Amsterdam, The Netherlands</json:string>
</affiliations>
</json:item>
<json:item>
<name>P.H Hartel</name>
<affiliations>
<json:string>Correspondence to: P.H. Hartel, Dept. of Computer Systems, University of Amsterdam, Kruislaan 403, 1098 SJ Amsterdam, The Netherlands.</json:string>
<json:string>Department of Computer Systems, University of Amsterdam, Kruislaan 403, 1098 SJ Amsterdam, The Netherlands</json:string>
</affiliations>
</json:item>
<json:item>
<name>L.O Hertzberger</name>
<affiliations>
<json:string>Department of Computer Systems, University of Amsterdam, Kruislaan 403, 1098 SJ Amsterdam, The Netherlands</json:string>
</affiliations>
</json:item>
<json:item>
<name>R.F.H Hofman</name>
<affiliations>
<json:string>Department of Computer Systems, University of Amsterdam, Kruislaan 403, 1098 SJ Amsterdam, The Netherlands</json:string>
</affiliations>
</json:item>
<json:item>
<name>K.G Langendoen</name>
<affiliations>
<json:string>Department of Computer Systems, University of Amsterdam, Kruislaan 403, 1098 SJ Amsterdam, The Netherlands</json:string>
</affiliations>
</json:item>
<json:item>
<name>L.L Li</name>
<affiliations>
<json:string>ECRC, Arabellastrasse 17, D-8000 Munich 81, Germany</json:string>
</affiliations>
</json:item>
<json:item>
<name>R Milikowski</name>
<affiliations>
<json:string>Department of Computer Systems, University of Amsterdam, Kruislaan 403, 1098 SJ Amsterdam, The Netherlands</json:string>
</affiliations>
</json:item>
<json:item>
<name>WG Vree</name>
<affiliations>
<json:string>Department of Computer Systems, University of Amsterdam, Kruislaan 403, 1098 SJ Amsterdam, The Netherlands</json:string>
</affiliations>
</json:item>
<json:item>
<name>H.P Barendregt</name>
<affiliations>
<json:string>Department of Computer Science, University of Nijmegen, Toernooiveld 1, 6252 ED Nijmegen, The Netherlands</json:string>
</affiliations>
</json:item>
<json:item>
<name>J.C Mulder</name>
<affiliations>
<json:string>Department of Computer Science, University of Nijmegen, Toernooiveld 1, 6252 ED Nijmegen, The Netherlands</json:string>
</affiliations>
</json:item>
</author>
<subject>
<json:item>
<lang>
<json:string>eng</json:string>
</lang>
<value>Clustered architecture</value>
</json:item>
<json:item>
<lang>
<json:string>eng</json:string>
</lang>
<value>parallelism</value>
</json:item>
<json:item>
<lang>
<json:string>eng</json:string>
</lang>
<value>functional programs</value>
</json:item>
</subject>
<arkIstex>ark:/67375/6H6-V1WZB2BM-2</arkIstex>
<language>
<json:string>eng</json:string>
</language>
<originalGenre>
<json:string>Full-length article</json:string>
</originalGenre>
<abstract>Abstract: A clustered architecture has been designed to exploit divide and conquer parallelism in functional programs. The programming methodology developed for the machine is based on explicit annotations and program transformations. It has been successfully applied to a number of algorithms resulting in a benchmark of small and medium size parallel functional programs. Sophisticated compilation techniques are used such as strictness analysis on non-flat domains and RISC and VLIW code generation. Parallel jobs are distributed by an efficient hierarchical scheduler. A special processor for graph reduction has been designed as a basic block for the machine. A prototype of a single cluster machine has been constructed with stock hardware. This paper describes the experience with the project and its current state.</abstract>
<qualityIndicators>
<score>8.452</score>
<pdfWordCount>14556</pdfWordCount>
<pdfCharCount>84310</pdfCharCount>
<pdfVersion>1.4</pdfVersion>
<pdfPageCount>26</pdfPageCount>
<pdfPageSize>540 x 749 pts</pdfPageSize>
<refBibsNative>true</refBibsNative>
<abstractWordCount>121</abstractWordCount>
<abstractCharCount>822</abstractCharCount>
<keywordCount>3</keywordCount>
</qualityIndicators>
<title>Experience with a clustered parallel reduction machine</title>
<pii>
<json:string>0167-739X(93)90011-D</json:string>
</pii>
<genre>
<json:string>research-article</json:string>
</genre>
<serie>
<title>Programming language design and implementation</title>
<language>
<json:string>unknown</json:string>
</language>
<pages>
<first>241</first>
<last>249</last>
</pages>
<conference>
<json:item>
<name>Programming language design and implementation - Atlanta, Georgia June 1988</name>
</json:item>
</conference>
</serie>
<host>
<title>Future Generation Computer Systems</title>
<language>
<json:string>unknown</json:string>
</language>
<publicationDate>1993</publicationDate>
<issn>
<json:string>0167-739X</json:string>
</issn>
<pii>
<json:string>S0167-739X(00)X0060-X</json:string>
</pii>
<volume>9</volume>
<issue>3</issue>
<pages>
<first>175</first>
<last>200</last>
</pages>
<genre>
<json:string>journal</json:string>
</genre>
</host>
<namedEntities>
<unitex>
<date>
<json:string>1993</json:string>
</date>
<geogName></geogName>
<orgName>
<json:string>University of Amsterdam</json:string>
<json:string>Department of Computer Science, University of Nijmegen, Toernooiveld</json:string>
<json:string>Netherlands Abstract A</json:string>
<json:string>Computer Systems</json:string>
<json:string>Science</json:string>
<json:string>the European Institute for Technology</json:string>
<json:string>Engineering Research Council</json:string>
<json:string>UK</json:string>
</orgName>
<orgName_funder>
<json:string>Science</json:string>
<json:string>the European Institute for Technology</json:string>
<json:string>Engineering Research Council</json:string>
<json:string>UK</json:string>
</orgName_funder>
<orgName_provider></orgName_provider>
<persName>
<json:string>John</json:string>
<json:string>Wang</json:string>
<json:string>Hugh Glaser</json:string>
<json:string>Henk Muller</json:string>
</persName>
<placeName>
<json:string>Munich</json:string>
<json:string>Nijmegen</json:string>
<json:string>Amsterdam</json:string>
<json:string>Glasgow</json:string>
<json:string>Netherlands</json:string>
</placeName>
<ref_url></ref_url>
<ref_bibl>
<json:string>[61]</json:string>
<json:string>[56]</json:string>
<json:string>[29]</json:string>
<json:string>[6]</json:string>
<json:string>[71]</json:string>
<json:string>[13,18]</json:string>
<json:string>[55]</json:string>
<json:string>[55, 54]</json:string>
<json:string>[17]</json:string>
<json:string>[1]</json:string>
<json:string>[65]</json:string>
<json:string>[38]</json:string>
<json:string>[3]</json:string>
<json:string>[42]</json:string>
<json:string>M. Beemster et al.</json:string>
<json:string>[5]</json:string>
<json:string>[67,39]</json:string>
<json:string>[48]</json:string>
<json:string>[20,66]</json:string>
<json:string>[30]</json:string>
<json:string>[7]</json:string>
<json:string>[12,33,56,70]</json:string>
<json:string>[47]</json:string>
<json:string>M. Beemster et aL</json:string>
<json:string>[10,69]</json:string>
<json:string>[30,43,57]</json:string>
<json:string>[3,40,43]</json:string>
<json:string>[62]</json:string>
<json:string>[30,52,51,37]</json:string>
<json:string>[46]</json:string>
<json:string>[19]</json:string>
</ref_bibl>
<bibl></bibl>
</unitex>
</namedEntities>
<ark>
<json:string>ark:/67375/6H6-V1WZB2BM-2</json:string>
</ark>
<categories>
<wos>
<json:string>1 - science</json:string>
<json:string>2 - computer science, theory & methods</json:string>
</wos>
<scienceMetrix>
<json:string>1 - applied sciences</json:string>
<json:string>2 - information & communication technologies</json:string>
<json:string>3 - distributed computing</json:string>
</scienceMetrix>
<scopus>
<json:string>1 - Physical Sciences</json:string>
<json:string>2 - Computer Science</json:string>
<json:string>3 - Computer Networks and Communications</json:string>
<json:string>1 - Physical Sciences</json:string>
<json:string>2 - Computer Science</json:string>
<json:string>3 - Hardware and Architecture</json:string>
<json:string>1 - Physical Sciences</json:string>
<json:string>2 - Computer Science</json:string>
<json:string>3 - Software</json:string>
</scopus>
<inist>
<json:string>1 - sciences appliquees, technologies et medecines</json:string>
<json:string>2 - sciences exactes et technologie</json:string>
<json:string>3 - sciences appliquees</json:string>
<json:string>4 - informatique. automatique theorique. systemes</json:string>
</inist>
</categories>
<publicationDate>1993</publicationDate>
<copyrightDate>1993</copyrightDate>
<doi>
<json:string>10.1016/0167-739X(93)90011-D</json:string>
</doi>
<id>86FDB730C5EA7FC7EDFA7D39BC30F5C066F72F62</id>
<score>1</score>
<fulltext>
<json:item>
<extension>pdf</extension>
<original>true</original>
<mimetype>application/pdf</mimetype>
<uri>https://api.istex.fr/ark:/67375/6H6-V1WZB2BM-2/fulltext.pdf</uri>
</json:item>
<json:item>
<extension>zip</extension>
<original>false</original>
<mimetype>application/zip</mimetype>
<uri>https://api.istex.fr/ark:/67375/6H6-V1WZB2BM-2/bundle.zip</uri>
</json:item>
<istex:fulltextTEI uri="https://api.istex.fr/ark:/67375/6H6-V1WZB2BM-2/fulltext.tei">
<teiHeader>
<fileDesc>
<titleStmt>
<title level="a">Experience with a clustered parallel reduction machine</title>
</titleStmt>
<publicationStmt>
<authority>ISTEX</authority>
<publisher scheme="https://scientific-publisher.data.istex.fr">ELSEVIER</publisher>
<availability>
<licence>
<p>elsevier</p>
</licence>
</availability>
<p scheme="https://loaded-corpus.data.istex.fr/ark:/67375/XBH-HKKZVM7B-M"></p>
<date>1993</date>
</publicationStmt>
<notesStmt>
<note type="research-article" scheme="https://content-type.data.istex.fr/ark:/67375/XTP-1JC4F85T-7">research-article</note>
<note type="journal" scheme="https://publication-type.data.istex.fr/ark:/67375/JMC-0GLKJH51-B">journal</note>
<note type="content">Section title: Paper</note>
</notesStmt>
<sourceDesc>
<biblStruct type="inbook">
<analytic>
<title level="a">Experience with a clustered parallel reduction machine</title>
<author xml:id="author-0000">
<persName>
<forename type="first">M</forename>
<surname>Beemster</surname>
</persName>
<affiliation>Department of Computer Systems, University of Amsterdam, Kruislaan 403, 1098 SJ Amsterdam, The Netherlands</affiliation>
</author>
<author xml:id="author-0001">
<persName>
<forename type="first">P.H</forename>
<surname>Hartel</surname>
</persName>
<affiliation>Correspondence to: P.H. Hartel, Dept. of Computer Systems, University of Amsterdam, Kruislaan 403, 1098 SJ Amsterdam, The Netherlands.</affiliation>
<affiliation>Department of Computer Systems, University of Amsterdam, Kruislaan 403, 1098 SJ Amsterdam, The Netherlands</affiliation>
</author>
<author xml:id="author-0002">
<persName>
<forename type="first">L.O</forename>
<surname>Hertzberger</surname>
</persName>
<affiliation>Department of Computer Systems, University of Amsterdam, Kruislaan 403, 1098 SJ Amsterdam, The Netherlands</affiliation>
</author>
<author xml:id="author-0003">
<persName>
<forename type="first">R.F.H</forename>
<surname>Hofman</surname>
</persName>
<affiliation>Department of Computer Systems, University of Amsterdam, Kruislaan 403, 1098 SJ Amsterdam, The Netherlands</affiliation>
</author>
<author xml:id="author-0004">
<persName>
<forename type="first">K.G</forename>
<surname>Langendoen</surname>
</persName>
<affiliation>Department of Computer Systems, University of Amsterdam, Kruislaan 403, 1098 SJ Amsterdam, The Netherlands</affiliation>
</author>
<author xml:id="author-0005">
<persName>
<forename type="first">L.L</forename>
<surname>Li</surname>
</persName>
<affiliation>ECRC, Arabellastrasse 17, D-8000 Munich 81, Germany</affiliation>
</author>
<author xml:id="author-0006">
<persName>
<forename type="first">R</forename>
<surname>Milikowski</surname>
</persName>
<affiliation>Department of Computer Systems, University of Amsterdam, Kruislaan 403, 1098 SJ Amsterdam, The Netherlands</affiliation>
</author>
<author xml:id="author-0007">
<persName>
<forename type="first">WG</forename>
<surname>Vree</surname>
</persName>
<affiliation>Department of Computer Systems, University of Amsterdam, Kruislaan 403, 1098 SJ Amsterdam, The Netherlands</affiliation>
</author>
<author xml:id="author-0008">
<persName>
<forename type="first">H.P</forename>
<surname>Barendregt</surname>
</persName>
<affiliation>Department of Computer Science, University of Nijmegen, Toernooiveld 1, 6252 ED Nijmegen, The Netherlands</affiliation>
</author>
<author xml:id="author-0009">
<persName>
<forename type="first">J.C</forename>
<surname>Mulder</surname>
</persName>
<affiliation>Department of Computer Science, University of Nijmegen, Toernooiveld 1, 6252 ED Nijmegen, The Netherlands</affiliation>
</author>
<idno type="istex">86FDB730C5EA7FC7EDFA7D39BC30F5C066F72F62</idno>
<idno type="ark">ark:/67375/6H6-V1WZB2BM-2</idno>
<idno type="DOI">10.1016/0167-739X(93)90011-D</idno>
<idno type="PII">0167-739X(93)90011-D</idno>
</analytic>
<monogr>
<title level="j">Future Generation Computer Systems</title>
<title level="j" type="abbrev">FUTURE</title>
<idno type="pISSN">0167-739X</idno>
<idno type="PII">S0167-739X(00)X0060-X</idno>
<imprint>
<publisher>ELSEVIER</publisher>
<date type="published" when="1993"></date>
<biblScope unit="volume">9</biblScope>
<biblScope unit="issue">3</biblScope>
<biblScope unit="page" from="175">175</biblScope>
<biblScope unit="page" to="200">200</biblScope>
</imprint>
</monogr>
</biblStruct>
</sourceDesc>
</fileDesc>
<profileDesc>
<creation>
<date>1993</date>
</creation>
<langUsage>
<language ident="en">en</language>
</langUsage>
<abstract xml:lang="en">
<p>Abstract: A clustered architecture has been designed to exploit divide and conquer parallelism in functional programs. The programming methodology developed for the machine is based on explicit annotations and program transformations. It has been successfully applied to a number of algorithms resulting in a benchmark of small and medium size parallel functional programs. Sophisticated compilation techniques are used such as strictness analysis on non-flat domains and RISC and VLIW code generation. Parallel jobs are distributed by an efficient hierarchical scheduler. A special processor for graph reduction has been designed as a basic block for the machine. A prototype of a single cluster machine has been constructed with stock hardware. This paper describes the experience with the project and its current state.</p>
</abstract>
<textClass>
<keywords scheme="keyword">
<list>
<head>Keywords</head>
<item>
<term>Clustered architecture</term>
</item>
<item>
<term>parallelism</term>
</item>
<item>
<term>functional programs</term>
</item>
</list>
</keywords>
</textClass>
</profileDesc>
<revisionDesc>
<change when="1993">Published</change>
</revisionDesc>
</teiHeader>
</istex:fulltextTEI>
<json:item>
<extension>txt</extension>
<original>false</original>
<mimetype>text/plain</mimetype>
<uri>https://api.istex.fr/ark:/67375/6H6-V1WZB2BM-2/fulltext.txt</uri>
</json:item>
</fulltext>
<metadata>
<istex:metadataXml wicri:clean="Elsevier, elements deleted: tail">
<istex:xmlDeclaration>version="1.0" encoding="utf-8"</istex:xmlDeclaration>
<istex:docType PUBLIC="-//ES//DTD journal article DTD version 4.5.2//EN//XML" URI="art452.dtd" name="istex:docType"></istex:docType>
<istex:document>
<converted-article version="4.5.2" docsubtype="fla">
<item-info>
<jid>FUTURE</jid>
<aid>9390011D</aid>
<ce:pii>0167-739X(93)90011-D</ce:pii>
<ce:doi>10.1016/0167-739X(93)90011-D</ce:doi>
<ce:copyright type="unknown" year="1993"></ce:copyright>
</item-info>
<head>
<ce:dochead>
<ce:textfn>Paper</ce:textfn>
</ce:dochead>
<ce:title>Experience with a clustered parallel reduction machine</ce:title>
<ce:author-group>
<ce:author>
<ce:given-name>M</ce:given-name>
<ce:surname>Beemster</ce:surname>
<ce:cross-ref refid="AFF1">
<ce:sup>a</ce:sup>
</ce:cross-ref>
</ce:author>
<ce:author>
<ce:given-name>P.H</ce:given-name>
<ce:surname>Hartel</ce:surname>
<ce:cross-ref refid="COR1">
<ce:sup></ce:sup>
</ce:cross-ref>
<ce:cross-ref refid="AFF1">
<ce:sup>a</ce:sup>
</ce:cross-ref>
</ce:author>
<ce:author>
<ce:given-name>L.O</ce:given-name>
<ce:surname>Hertzberger</ce:surname>
<ce:cross-ref refid="AFF1">
<ce:sup>a</ce:sup>
</ce:cross-ref>
</ce:author>
<ce:author>
<ce:given-name>R.F.H</ce:given-name>
<ce:surname>Hofman</ce:surname>
<ce:cross-ref refid="AFF1">
<ce:sup>a</ce:sup>
</ce:cross-ref>
</ce:author>
<ce:author>
<ce:given-name>K.G</ce:given-name>
<ce:surname>Langendoen</ce:surname>
<ce:cross-ref refid="AFF1">
<ce:sup>a</ce:sup>
</ce:cross-ref>
</ce:author>
<ce:author>
<ce:given-name>L.L</ce:given-name>
<ce:surname>Li</ce:surname>
<ce:cross-ref refid="AFF2">
<ce:sup>b</ce:sup>
</ce:cross-ref>
</ce:author>
<ce:author>
<ce:given-name>R</ce:given-name>
<ce:surname>Milikowski</ce:surname>
<ce:cross-ref refid="AFF1">
<ce:sup>a</ce:sup>
</ce:cross-ref>
</ce:author>
<ce:author>
<ce:given-name>WG</ce:given-name>
<ce:surname>Vree</ce:surname>
<ce:cross-ref refid="AFF1">
<ce:sup>a</ce:sup>
</ce:cross-ref>
</ce:author>
<ce:author>
<ce:given-name>H.P</ce:given-name>
<ce:surname>Barendregt</ce:surname>
<ce:cross-ref refid="AFF3">
<ce:sup>c</ce:sup>
</ce:cross-ref>
</ce:author>
<ce:author>
<ce:given-name>J.C</ce:given-name>
<ce:surname>Mulder</ce:surname>
<ce:cross-ref refid="AFF3">
<ce:sup>c</ce:sup>
</ce:cross-ref>
</ce:author>
<ce:affiliation id="AFF1">
<ce:label>a</ce:label>
<ce:textfn>Department of Computer Systems, University of Amsterdam, Kruislaan 403, 1098 SJ Amsterdam, The Netherlands</ce:textfn>
</ce:affiliation>
<ce:affiliation id="AFF2">
<ce:label>b</ce:label>
<ce:textfn>ECRC, Arabellastrasse 17, D-8000 Munich 81, Germany</ce:textfn>
</ce:affiliation>
<ce:affiliation id="AFF3">
<ce:label>c</ce:label>
<ce:textfn>Department of Computer Science, University of Nijmegen, Toernooiveld 1, 6252 ED Nijmegen, The Netherlands</ce:textfn>
</ce:affiliation>
<ce:correspondence id="COR1">
<ce:label></ce:label>
<ce:text>Correspondence to: P.H. Hartel, Dept. of Computer Systems, University of Amsterdam, Kruislaan 403, 1098 SJ Amsterdam, The Netherlands.</ce:text>
</ce:correspondence>
</ce:author-group>
<ce:abstract>
<ce:section-title>Abstract</ce:section-title>
<ce:abstract-sec>
<ce:simple-para>A clustered architecture has been designed to exploit divide and conquer parallelism in functional programs. The programming methodology developed for the machine is based on explicit annotations and program transformations. It has been successfully applied to a number of algorithms resulting in a benchmark of small and medium size parallel functional programs. Sophisticated compilation techniques are used such as strictness analysis on non-flat domains and RISC and VLIW code generation. Parallel jobs are distributed by an efficient hierarchical scheduler. A special processor for graph reduction has been designed as a basic block for the machine. A prototype of a single cluster machine has been constructed with stock hardware. This paper describes the experience with the project and its current state.</ce:simple-para>
</ce:abstract-sec>
</ce:abstract>
<ce:keywords>
<ce:section-title>Keywords</ce:section-title>
<ce:keyword>
<ce:text>Clustered architecture</ce:text>
</ce:keyword>
<ce:keyword>
<ce:text>parallelism</ce:text>
</ce:keyword>
<ce:keyword>
<ce:text>functional programs</ce:text>
</ce:keyword>
</ce:keywords>
</head>
</converted-article>
</istex:document>
</istex:metadataXml>
<mods version="3.6">
<titleInfo>
<title>Experience with a clustered parallel reduction machine</title>
</titleInfo>
<titleInfo type="alternative" contentType="CDATA">
<title>Experience with a clustered parallel reduction machine</title>
</titleInfo>
<name type="personal">
<namePart type="given">M</namePart>
<namePart type="family">Beemster</namePart>
<affiliation>Department of Computer Systems, University of Amsterdam, Kruislaan 403, 1098 SJ Amsterdam, The Netherlands</affiliation>
<role>
<roleTerm type="text">author</roleTerm>
</role>
</name>
<name type="personal">
<namePart type="given">P.H</namePart>
<namePart type="family">Hartel</namePart>
<affiliation>Correspondence to: P.H. Hartel, Dept. of Computer Systems, University of Amsterdam, Kruislaan 403, 1098 SJ Amsterdam, The Netherlands.</affiliation>
<affiliation>Department of Computer Systems, University of Amsterdam, Kruislaan 403, 1098 SJ Amsterdam, The Netherlands</affiliation>
<role>
<roleTerm type="text">author</roleTerm>
</role>
</name>
<name type="personal">
<namePart type="given">L.O</namePart>
<namePart type="family">Hertzberger</namePart>
<affiliation>Department of Computer Systems, University of Amsterdam, Kruislaan 403, 1098 SJ Amsterdam, The Netherlands</affiliation>
<role>
<roleTerm type="text">author</roleTerm>
</role>
</name>
<name type="personal">
<namePart type="given">R.F.H</namePart>
<namePart type="family">Hofman</namePart>
<affiliation>Department of Computer Systems, University of Amsterdam, Kruislaan 403, 1098 SJ Amsterdam, The Netherlands</affiliation>
<role>
<roleTerm type="text">author</roleTerm>
</role>
</name>
<name type="personal">
<namePart type="given">K.G</namePart>
<namePart type="family">Langendoen</namePart>
<affiliation>Department of Computer Systems, University of Amsterdam, Kruislaan 403, 1098 SJ Amsterdam, The Netherlands</affiliation>
<role>
<roleTerm type="text">author</roleTerm>
</role>
</name>
<name type="personal">
<namePart type="given">L.L</namePart>
<namePart type="family">Li</namePart>
<affiliation>ECRC, Arabellastrasse 17, D-8000 Munich 81, Germany</affiliation>
<role>
<roleTerm type="text">author</roleTerm>
</role>
</name>
<name type="personal">
<namePart type="given">R</namePart>
<namePart type="family">Milikowski</namePart>
<affiliation>Department of Computer Systems, University of Amsterdam, Kruislaan 403, 1098 SJ Amsterdam, The Netherlands</affiliation>
<role>
<roleTerm type="text">author</roleTerm>
</role>
</name>
<name type="personal">
<namePart type="given">WG</namePart>
<namePart type="family">Vree</namePart>
<affiliation>Department of Computer Systems, University of Amsterdam, Kruislaan 403, 1098 SJ Amsterdam, The Netherlands</affiliation>
<role>
<roleTerm type="text">author</roleTerm>
</role>
</name>
<name type="personal">
<namePart type="given">H.P</namePart>
<namePart type="family">Barendregt</namePart>
<affiliation>Department of Computer Science, University of Nijmegen, Toernooiveld 1, 6252 ED Nijmegen, The Netherlands</affiliation>
<role>
<roleTerm type="text">author</roleTerm>
</role>
</name>
<name type="personal">
<namePart type="given">J.C</namePart>
<namePart type="family">Mulder</namePart>
<affiliation>Department of Computer Science, University of Nijmegen, Toernooiveld 1, 6252 ED Nijmegen, The Netherlands</affiliation>
<role>
<roleTerm type="text">author</roleTerm>
</role>
</name>
<typeOfResource>text</typeOfResource>
<genre type="research-article" displayLabel="Full-length article" authority="ISTEX" authorityURI="https://content-type.data.istex.fr" valueURI="https://content-type.data.istex.fr/ark:/67375/XTP-1JC4F85T-7">research-article</genre>
<originInfo>
<publisher>ELSEVIER</publisher>
<dateIssued encoding="w3cdtf">1993</dateIssued>
<copyrightDate encoding="w3cdtf">1993</copyrightDate>
</originInfo>
<language>
<languageTerm type="code" authority="iso639-2b">eng</languageTerm>
<languageTerm type="code" authority="rfc3066">en</languageTerm>
</language>
<abstract lang="en">Abstract: A clustered architecture has been designed to exploit divide and conquer parallelism in functional programs. The programming methodology developed for the machine is based on explicit annotations and program transformations. It has been successfully applied to a number of algorithms resulting in a benchmark of small and medium size parallel functional programs. Sophisticated compilation techniques are used such as strictness analysis on non-flat domains and RISC and VLIW code generation. Parallel jobs are distributed by an efficient hierarchical scheduler. A special processor for graph reduction has been designed as a basic block for the machine. A prototype of a single cluster machine has been constructed with stock hardware. This paper describes the experience with the project and its current state.</abstract>
<note type="content">Section title: Paper</note>
<subject>
<genre>Keywords</genre>
<topic>Clustered architecture</topic>
<topic>parallelism</topic>
<topic>functional programs</topic>
</subject>
<relatedItem type="host">
<titleInfo>
<title>Future Generation Computer Systems</title>
</titleInfo>
<titleInfo type="abbreviated">
<title>FUTURE</title>
</titleInfo>
<genre type="journal" authority="ISTEX" authorityURI="https://publication-type.data.istex.fr" valueURI="https://publication-type.data.istex.fr/ark:/67375/JMC-0GLKJH51-B">journal</genre>
<originInfo>
<publisher>ELSEVIER</publisher>
<dateIssued encoding="w3cdtf">1993</dateIssued>
</originInfo>
<identifier type="ISSN">0167-739X</identifier>
<identifier type="PII">S0167-739X(00)X0060-X</identifier>
<part>
<date>1993</date>
<detail type="volume">
<number>9</number>
<caption>vol.</caption>
</detail>
<detail type="issue">
<number>3</number>
<caption>no.</caption>
</detail>
<extent unit="issue-pages">
<start>163</start>
<end>283</end>
</extent>
<extent unit="pages">
<start>175</start>
<end>200</end>
</extent>
</part>
</relatedItem>
<identifier type="istex">86FDB730C5EA7FC7EDFA7D39BC30F5C066F72F62</identifier>
<identifier type="ark">ark:/67375/6H6-V1WZB2BM-2</identifier>
<identifier type="DOI">10.1016/0167-739X(93)90011-D</identifier>
<identifier type="PII">0167-739X(93)90011-D</identifier>
<recordInfo>
<recordContentSource authority="ISTEX" authorityURI="https://loaded-corpus.data.istex.fr" valueURI="https://loaded-corpus.data.istex.fr/ark:/67375/XBH-HKKZVM7B-M">elsevier</recordContentSource>
</recordInfo>
</mods>
<json:item>
<extension>json</extension>
<original>false</original>
<mimetype>application/json</mimetype>
<uri>https://api.istex.fr/ark:/67375/6H6-V1WZB2BM-2/record.json</uri>
</json:item>
</metadata>
</istex>
</record>

Pour manipuler ce document sous Unix (Dilib)

EXPLOR_STEP=$WICRI_ROOT/Wicri/Lorraine/explor/InforLorV4/Data/Istex/Corpus
HfdSelect -h $EXPLOR_STEP/biblio.hfd -nk 001F28 | SxmlIndent | more

Ou

HfdSelect -h $EXPLOR_AREA/Data/Istex/Corpus/biblio.hfd -nk 001F28 | SxmlIndent | more

Pour mettre un lien sur cette page dans le réseau Wicri

{{Explor lien
   |wiki=    Wicri/Lorraine
   |area=    InforLorV4
   |flux=    Istex
   |étape=   Corpus
   |type=    RBID
   |clé=     ISTEX:86FDB730C5EA7FC7EDFA7D39BC30F5C066F72F62
   |texte=   Experience with a clustered parallel reduction machine
}}

Wicri

This area was generated with Dilib version V0.6.33.
Data generation: Mon Jun 10 21:56:28 2019. Site generation: Fri Feb 25 15:29:27 2022