-
Notifications
You must be signed in to change notification settings - Fork 0
/
readme_log.txt
1403 lines (1179 loc) · 55.8 KB
/
readme_log.txt
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
RELEASE NOTES IN THE PAST
-------------------------
-------------------------------------------------------------------------------
RELEASE
-------------------------------------------------------------------------------
Cetus 1.4.0 Binary Release (January 24, 2013)
Cetus 1.4.0 is only a binary release and a full release is forthcoming.
Cetus is a source-to-source compiler infrastructure for C written in Java, and
can be downloaded from http://cetus.ecn.purdue.edu. This version added a graphic
user interface (GUI) and contains minor updates and fixes in the existing passes.
-------------------------------------------------------------------------------
FEATURES/UPDATES
-------------------------------------------------------------------------------
* New features
- Added GUI into Cetus. GUI can be started by adding flag "-gui".
- Turning off all flags makes the most powerful options. Running "cetus foo.c" or "java -jar cetusgui.jar foo.c"
turns on the following options implicitly:
-parser=cetus.base.grammars.CetusCParser
-induction=3
-outdir=cetus_output
-preprocessor=cpp-3.exe -E (for Windows)
-preprocessor=cpp -C -I. (for Linux and Mac)
-privatize=2
-reduction=2
-verbosity=0
-ddt=2
-parallelize-loops=1
-ompGen=1
-alias=1
-range=1
-teliminate-branch=1
-profitable-omp=1
- Cetus version check: Cetus will automatically check cetus.ecn.purdue.edu and remind user if new version is available.
* Updates
- Some numbers in options have been changed.
* Bug fixes and improvements
* Updates in flags
-------------------------------------------------------------------------------
CONTENTS
-------------------------------------------------------------------------------
This Cetus release has the following contents.
lib - Archived classes (jar)
src - Cetus source code
license_antlr.txt - ANTLR license
license.txt - Cetus license
build.sh - Command line build script
build.xml - Build configuration for Apache Ant
readme.txt - This file
readme_log.txt - Archived release notes
readme_omp2gpu.txt - readme file for OpenMP-to-CUDA translator
-------------------------------------------------------------------------------
REQUIREMENTS
-------------------------------------------------------------------------------
* JAVA SE 6
* ANTLRv2
* GCC (Cygwin GCC for Windows OS)
-------------------------------------------------------------------------------
INSTALLATION
-------------------------------------------------------------------------------
* Obtain Cetus distribution
The latest version of Cetus can be obtained at:
http://cetus.ecn.purdue.edu/
* Binary Version
For binary version (.jar) of Cetus, installation is not needed.
* Unpack
Users need to unpack the distribution before installing Cetus.
$ cd <directory_where_cetus.tar.gz_exists>
$ gzip -d cetus.tar.gz | tar xvf -
* Build
There are several options for building Cetus:
- For Apache Ant users
The provided build.xml defines the build targets for Cetus. The available
targets are "compile", "jar", "clean" and "javadoc". Users need to edit
the location of the Antlr tool.
- For Linux/Unix command line users
Run the script build.sh after defining system-dependent variables in the
script.
- For SDK (Eclipse, Netbeans, etc) users
First, build the parser with the Antlr tool.
Then, follow the instructions of each SDK to set up a project.
-------------------------------------------------------------------------------
RUNNING CETUS
-------------------------------------------------------------------------------
Users can run Cetus in the following way:
$ java -classpath=<user_class_path> cetus.exec.Driver <options> <C files>
The "user_class_path" should include the class paths of Antlr and Cetus.
"build.sh" and "build.xml" provides a target that generates a wrapper script
for Cetus users.
- Like previous versions, you can still run command line version of Cetus by running "cetus" or "java -jar
cetusgui.jar" plus flags (options) and input C file, e.g. "cetus foo.c" or "java -jar cetusgui.jar foo.c" for
processing C file with the default options.
- You can start Cetus GUI by double-clicking cetusgui.jar if your OS supports it. You can also start Cetus GUI by
running "java -jar cetusgui.jar" or "java -jar cetusgui.jar -gui" in command line. Starting Cetus GUI through command
line should work on all Windows, Linux and Mac. Previous script "cetus" is still working and "cetus gui" starts GUI
too.
- If you want to process your C code by Cetus on Windows, a preprocessor, i.e. Cygwin gcc (cpp-3.exe), must be
installed. However, compiling C code by Cetus with Cygwin on Windows has not been fully tested and is not guaranteed to
work. Also, after installing Cygwin on Windows, the path to cpp-3.exe (e.g. C:\cygwin\bin) must be set in Environment
Variables on Windows.
- The binary version is only for personal and academic use, not for commercial use. The license files of ANTLR and
Cetus are also included in cetusgui.jar. We will regularly update the binary version. Please always visit Cetus website
and download the latest version.
-------------------------------------------------------------------------------
TESTING
-------------------------------------------------------------------------------
We have tested Cetus successfully using the following benchmark suites:
* SPEC CPU2006
More information about this suite is available at http://www.spec.org
* SPEC OMP2001
More information about this suite is available at http://www.spec.org
* NPB 2.3 written in C
More information about this suite is available at
http://www.hpcs.cs.tsukuba.ac.jp/omni-openmp/
January 24, 2013
The Cetus Team
URL: http://cetus.ecn.purdue.edu
EMAIL: cetus@ecn.purdue.edu
-------------------------------------------------------------------------------
RELEASE
-------------------------------------------------------------------------------
Cetus 1.3.1 (June 5, 2012)
Cetus is a source-to-source compiler infrastructure for C written in Java, and
can be downloaded from http://cetus.ecn.purdue.edu. This version contains
minor updates and fixes in the existing passes.
-------------------------------------------------------------------------------
FEATURES/UPDATES
-------------------------------------------------------------------------------
* New features
- Added partial support for c99 features including mixed declarations and
code, new block scope for iteration statements, designated initializers,
compound literals, hexadecimal floating constants, and restrict pointers.
Visit the link below to find out more details about these c99 features:
http://cetus.ecn.purdue.edu/FAQ/unsupported_c99_features.html
- Added program slicing tools in the cetus.application package, which is based
on the def-use/use-def chain tools. This package is still experimental.
* Updates
- OpenMPC code (omp2gpu package) has been updated to v0.3.1. The code is still
experimental; more information about this package is available at
https://engineering.purdue.edu/paramnt/OpenMPC
* Bug fixes and improvements
- Enhanced the accuracy of the data dependence graph by excluding unreachable
dependence pair under the "equal" direction vector.
- Fixed a bug in the data dependence test which was not doing the merge
operation of direction vectors in certain types of multiple subscripts.
- Fixed a bug in the parser which was not handling certain types of struct
declaration with bit fields.
- Fixed a bug in the induction variable substitution pass which was failing
to generate runtime test for possible zero-trip loops in some cases.
- Fixed a bug in IR consistency checker which was not strong enough to check
a certain type of garbled IR.
- Fixed a bug in the branch eliminator which was not removing code section
in certain types of "if" statements.
- Fixed a bug in the IRTools.isReachable() method.
* Updates in flags
- Modified flags
-induction=N
Added sub options which processes only linear induction variables.
-privatize=N
Added sub options which processes only scalar variables.
-------------------------------------------------------------------------------
CONTENTS
-------------------------------------------------------------------------------
This Cetus release has the following contents.
lib - Archived classes (jar)
license.txt - Cetus license
build.sh - Command line build script
build.xml - Build configuration for Apache Ant
src - Cetus source code
readme.txt - This file
readme_log.txt - Archived release notes
readme_omp2gpu.txt - readme file for OpenMP-to-CUDA translator
-------------------------------------------------------------------------------
REQUIREMENTS
-------------------------------------------------------------------------------
* JAVA SE 6
* ANTLRv2
* GCC
-------------------------------------------------------------------------------
INSTALLATION
-------------------------------------------------------------------------------
* Obtain Cetus distribution
The latest version of Cetus can be obtained at:
http://cetus.ecn.purdue.edu/
* Unpack
Users need to unpack the distribution before installing Cetus.
$ cd <directory_where_cetus.tar.gz_exists>
$ gzip -d cetus.tar.gz | tar xvf -
* Build
There are several options for building Cetus:
- For Apache Ant users
The provided build.xml defines the build targets for Cetus. The available
targets are "compile", "jar", "clean" and "javadoc". Users need to edit
the location of the Antlr tool.
- For Linux/Unix command line users
Run the script build.sh after defining system-dependent variables in the
script.
- For SDK (Eclipse, Netbeans, etc) users
First, build the parser with the Antlr tool.
Then, follow the instructions of each SDK to set up a project.
-------------------------------------------------------------------------------
RUNNING CETUS
-------------------------------------------------------------------------------
Users can run Cetus in the following way:
$ java -classpath=<user_class_path> cetus.exec.Driver <options> <C files>
The "user_class_path" should include the class paths of Antlr and Cetus.
"build.sh" and "build.xml" provides a target that generates a wrapper script
for Cetus users.
-------------------------------------------------------------------------------
TESTING
-------------------------------------------------------------------------------
We have tested Cetus successfully using the following benchmark suites:
* SPEC CPU2006
More information about this suite is available at http://www.spec.org
* SPEC OMP2001
More information about this suite is available at http://www.spec.org
* NPB 2.3 written in C
More information about this suite is available at
http://www.hpcs.cs.tsukuba.ac.jp/omni-openmp/
June 5, 2012
The Cetus Team
URL: http://cetus.ecn.purdue.edu
EMAIL: cetus@ecn.purdue.edu
--------------------------------------------------------------------------------
RELEASE
--------------------------------------------------------------------------------
Cetus 1.3 (June 13, 2011)
Cetus is a source-to-source compiler infrastructure for C written in Java, and
can be downloaded from http://cetus.ecn.purdue.edu. This version contains
improvements to various analysis/transformation passes, both in their
effectiveness and efficiency.
As a side note, we are preparing for Cetus Users and Compiler Infrastructure
Workshop in October -- visit http://cetus.ecn.purdue.edu/cetusworkshop for more
information.
--------------------------------------------------------------------------------
FEATURES/UPDATES
--------------------------------------------------------------------------------
* Bug fixes
- Points-to analysis produces the same result over repeated invocations while
the previous version did not.
- Added checks in LoopProfiler to avoid profiling loops that contain jumps to
program points other than the loop exits.
- Fixed the OpenMP code generator so that it excludes variables declared
within the relevant loop from the private clause.
- Fixed the expression simplifier's behavior that produced incorrect results
on logical expressions.
- Fixed the dependence analyzer's behavior that produced incorrect results on
certain scalar variables which contain pointer dereferences.
- Fixed a bug that prevented selecting parallel loops for OpenMP
parallelization in certain cases.
* New analysis/transform passes
- Inline expansion
This pass has been mature since the last release. Various sub-options
provide configurable behaviors of the inline transformation.
- Unreachable branch elimination
This pass detects unreachable code due to branches that can be evaluated
at compile time and eliminates such code. The tested branches are in IF,
FOR, WHILE, DO, and SWITCH statements. See the "-teliminate-branch" flag to
see how to invoke this transformation.
- Reduction transform
This pass produces OpenMP-conforming code from the reduction items
recognized by the reduction analysis in Cetus. Two types of transformations
are performed; one is scalar replacement for loop-invariant expressions, and
the other is array reduction code generation. This transformation pass is
invoked by adjusting the value of the flag "-reduction".
- Def-Use chains and its interface
This analysis computes def-use chains and use-def chains
interprocedurally for a program. The analysis returns a list of
statements from a given def or use expression. The analysis is located
in the package "cetus.application". The interface, DefUseChain and
UseDefChain, and its implementation, IPChainAnalysis are the key classes
for this feature.
* Updates to automatic parallelization
- Enhanced report of automatic parallelization
We added options that enables detailed reporting of automatic
parallelization. The report shows variables that may carry data dependences
if the enclosing loop is not parallelized.
This reporting is turned on when users pass the following flags:
-parallelize-loops=3
Every loop is analyzed for automatic parallelization but only the
outermost parallel loops are scheduled for parallelization (OpenMP)
-parallelize-loops=4
Every loop is analyzed for automatic parallelization and every parallel
loop is scheduled for parallelization
- Enhanced handling of known library calls
Handling of library calls in analysis passes has been improved to produce
less conservative analysis results. We inserted comprehensive check routines
in range analysis, array privatization pass, and loop parallelization pass
so that they identify side-effect-free standard library calls and make less
conservative decisions. This behavior is unsafe when the input program
contains a call to a non-standard-library function that matches the
signature of a standard-library function.
- Enhanced handling of reductions
The previous version was not properly handling reduction items that do not
conform to the OpenMP specification. A new pass was added and called by the
loop parallelization pass to overcome this limitation.
See the "ReductionTransform" pass for more details.
- Enhanced OpenMP code generation with a simple performance model
Cetus' OpenMP code generator now inserts simple run-time checks through
OpenMP IF clauses so that it serialize parallel loops that contain
insufficient work.
- As a result, the current version finds 21 more parallel loops than the
previous version does for our test suite (NPB, SPEC OMP).
* Updates for efficiency and consistency
We found that Cetus suffers from limited scalability in terms of memory usage
and put significant effort into improving Cetus' memory usage. This
optimization includes minimization of object clones, use of in-place
operations if possible, use of efficient collections, and other optimizations
for time efficiency.
The following numbers summarize the result of this optimization:
Improvements since the last release (1.2.1)
Environments: Quad-core AMD Opteron at 2.5GHz
JAVA SE 1.6.0_25 with -Xmx=1500m
Elapsed time for building and printing IRs for 25 NPB/SPEC codes
1.2.1 : 709 seconds
1.3 : 242 seconds
Elapsed time for automatic parallelization for 11 NPB/SPEC codes
1.2.1 : 143 seconds
1.3 : 110 seconds
* Updates in flags
- New flags
-debug_parser_input
Print a single preprocessed input file before sending it to the parser,
and exit
-debug_preprocessor_input
Print a single pre-annotated input file before sending it to the
preprocessor, and exit
-dump-options
Create file options.cetus with default options
-dump-system-options
Create a system wide file options.cetus with default options
-parser=PARSERNAME
Name of the parser to be used for parsing the source files
-teliminate-branch=N
Eliminates unreachable branch targets
-tinline=SUBOPTION
This flags replaces "-tinline-expansion"
-profitable-omp=N
Inserts runtime checks for selecting profitable omp parallel region
- Modified flags
-ddt=N
ddt=3 was removed from the help message
-parallelize-loops=N
By default, only outermost loops are parallelized
Added options for printing parallelization report
-profile-loops=N
Clarified the types of profiled regions -- loop, OpenMP parallel region,
and OpenMP for loop
- Removed flags
-tinline-expansion
-tinline replaces this flag
--------------------------------------------------------------------------------
CONTENTS
--------------------------------------------------------------------------------
This Cetus release has the following contents.
lib - Archived classes (jar)
license.txt - Cetus license
build.sh - Command line build script
build.xml - Build configuration for Apache Ant
src - Cetus source code
readme.txt - This file
readme_log.txt - Archived release notes
readme_omp2gpu.txt - readme file for OpenMP-to-CUDA translator
--------------------------------------------------------------------------------
REQUIREMENTS
--------------------------------------------------------------------------------
* JAVA SE 6
* ANTLRv2
* GCC
--------------------------------------------------------------------------------
INSTALLATION
--------------------------------------------------------------------------------
* Obtain Cetus distribution
The latest version of Cetus can be obtained at:
http://cetus.ecn.purdue.edu/
* Unpack
Users need to unpack the distribution before installing Cetus.
$ cd <directory_where_cetus.tar.gz_exists>
$ gzip -d cetus.tar.gz | tar xvf -
* Build
There are several options for building Cetus:
- For Apache Ant users
The provided build.xml defines the build targets for Cetus. The available
targets are "compile", "jar", "clean" and "javadoc". Users need to edit
the location of the Antlr tool.
- For Linux/Unix command line users.
Run the script build.sh after defining system-dependent variables in the
script.
- For SDK (Eclipse, Netbeans, etc) users
Follow the instructions of each SDK.
--------------------------------------------------------------------------------
RUNNING CETUS
--------------------------------------------------------------------------------
Users can run Cetus in the following way:
$ java -classpath=<user_class_path> cetus.exec.Driver <options> <C files>
The "user_class_path" should include the class paths of Antlr and Cetus.
"build.sh" and "build.xml" provides a target that generates a wrapper script
for Cetus users.
--------------------------------------------------------------------------------
TESTING
--------------------------------------------------------------------------------
We have tested Cetus successfully using the following benchmark suites:
* SPEC CPU2006
More information about this suite is available at http://www.spec.org
* SPEC OMP2001
More information about this suite is available at http://www.spec.org
* NPB 2.3 written in C
More information about this suite is available at
http://www.hpcs.cs.tsukuba.ac.jp/omni-openmp/
June 13, 2011
The Cetus Team
URL: http://cetus.ecn.purdue.edu
EMAIL: cetus@ecn.purdue.edu
RELEASE
-------
Cetus 1.2.1 (September 10, 2010)
Cetus is a source-to-source compiler infrastructure for C written in Java.
http://cetus.ecn.purdue.edu. This release is a minor one that includes updates
for bug fixes since version 1.2. If you are interested in the OpenMP-to-CUDA
package, check readme.omp2gpu for more details.
FEATURES/UPDATES
----------------
* Bug fixes
version 1.2.1
- Fixed bugs in points-to analysis which misses points-to relationship when
passing a whole global array as a parameter.
- Fixed incorrect and inefficient use of alias analysis during data dependence
analysis.
- Fixed incorrect transformation in the following normalizing passes.
Single-call transformation (-tsingle-call)
Loop-normalization transformation (-normalize-loops)
- Improved stability of the inline expansion transformation.
- Several bug fixes in OpenMP-to-CUDA translator (see readme.omp2gpu).
version 1.2
- Minimal support for GCC __asm__ extension.
- K&R-style functions can be preserved in the output code with a command-line
option.
* New flags
-alias=N
Specify level of alias analysis
=0 disable alias analysis
=1 advanced interprocedural analysis (default)
Uses interprocedural points-to analysis
-normalize-return-stmt
Normalize return statements for all procedures
-range=N
Specifies the accuracy of symbolic analysis with value ranges
=0 disable range computation (minimal symbolic analysis)
=1 enable local range computation (default)
=2 enable inter-procedural computation (experimental)
-preserve-KR-function
Preserves K&R-style function declaration
* Updated flags
-ddt=N
Perform Data Dependence Testing
=1 banerjee-wolfe test (default)
=2 range test
-reduction=N
Perform reduction variable analysis
=1 enable only scalar reduction analysis (default)
=2 enable array reduction analysis as well
* Removed flags
-argument-noalias -> merged into -alias flag
-argument-noalias-global -> merged into -alias flag
-no-alias -> merged into -alias flag
-no-side-effect -> obsolete
-normalize -> renamed as -normalize-loops
-loop-interchange -> not active
-loop-tiling -> not active
* Experimental flags
-tinline-expansion
* Updates in cetus.hir package
- Identifier and Symbol interface
We found that management of identifiers and symbols in the previous version
may introduce IR inconsistency when a transformation pass makes low-level
modifications to the program IR, resulting in a descent amount of increase
in development time. To alleviate this problem, we decided to choose
consistency over flexibility in the Cetus IR. One important
consistency-enhancing change is to protect low-level modifications related
to symbol and identifiers. The followings list the outstanding differences
from the previous Cetus IR.
1. Construction of an Identifier object from a string name is prohibited.
An Identifier object should be created from a Symbol object that has been
created before the Identifier is being created.
2. A new class, NameID, is used in place of Identifier when it needs direct
name creation. Declaring variables, functions, and user types falls to
this situation.
3. The link to the corresponding Symbol object is stored in an Identifier
object, not in an IDExpression object.
4. Direct modification to the symbol look-up table in a SymbolTable object
is prohibited. It is still possible to access the list of declarations and
symbols through the newly added interface methods SymbolTable.getSymbols()
and SymbolTable.getDeclarations().
- Protection of IR
We also found many modification operations may allow reuse of a Traversable
object that is already in the program IR, which should not be allowed.
Typical examples of such operations are constructors and high-level
modifiers of the IR classes. We revisited the implementation of such
operations and provided a safety net by making them throw exceptions when
they encounter such attempts.
- IR comparison
The comparison semantics of the base classes were clarified. We have been
using Traversable objects in a collection without explicitly defined
comparison methods. We provided implementation of equals() and hashCode()
methods in the four base classes, Declaration, Declarator, Expression, and
Statement. Expression is the only base IR that performs contents comparison,
with the others performing identity comparison.
- Comprehensive list of changes in cetus.hir package
1. Added NameID.java (see "Identifier and Symbol interface")
2. IDExpression.getSymbol() .setSymbol() were moved to Identifier.java
3. SymbolTable.getTable() was removed
4. Added containsSymbol(), containsDeclaration(), getSymbols(), and
getDeclarations() in SymbolTable.java
5. Added getDeclaration() and setName() in Symbol.java
6. Added missing equals() and hashCode() methods in the base classes
7. Disabled addition of a DeclarationStatement object to a CompoundStatement
object (respecting the C language)
8. Separated Tools.java into DataFlowTools, IRTools, PrintTools,
SymbolTools, and Tools, following their semantics. Access to Tools method
is still allowed but will throw "deprecated" warnings.
9. Added StandardLibrary.java for minimal support of standard library calls.
* New analysis passes
- Interprocedural analysis (IPA)
Basic tools for performing interprocedural analysis are provided. The tools
include call-graph/workspace generation and a set of simple solvers. The
call-graph utility is implemented in IPAGraph, IPANode, and CallSite classes
in the cetus.analysis package, and those classes represent a call graph, a
node in the graph, and a call site in the graph respectively. Base framework
for IPA is implemented in IPAnalysis, from which pass writers can
instantiate their own IPA passes.
The current version of Cetus uses this common framework to increase the
capability of Range analysis and Points-to analysis.
- Points-to analysis
Cetus now provides a powerful pointer analysis framework through its
implementation of an interprocedural points-to analyzer based on the
design described in:
"A practice interprocedural alias analysis for an optimizing/parallelizing
C compiler", M. Emami, McGill University, 1993.
PointsToAnalysis implements an intraprocedural flow-sensitive
driver for this analyzer. Pointer relationships are created at
every program point i.e. every Statement, through iterative work-list
based traversal of the control flow graph provided by CFGraph.
Data structure information and functionality for representing and
handling these pointer relationships can be found in PointsToDomain,
PointsToRel, UniverseDomain and the Symbol interface. The output
of the intraprocedural analysis which is a map from Statement to
PointsToDomain (set of points-to information), is used by the
interprocedural analyzer.
The interprocedural analysis of points-to relation was built upon the
common interprocedural framework introduced in the current version. The
role of the interprocedural analysis is to reflect the effect of entering
or returning from a called procedure, by appropriately renaming the
variables that appear in the points-to relations. The renaming algorithm is
quite similar to one that appears in the reference implementation, but we
adjusted the interprocedural driver so that it works on top of our common
IPA framework. Currently, the IPA points-to analysis does not support full
context sensitivity and gives up analysis of programs containing function
calls through function pointers.
Currently, we have extensively tested and verified the results of the points-to
analysis framework on the SPEC OMP2001 (except ammp) and NPB benchmark suites.
* Updates to Alias Analysis
Cetus originally provided a simple conservative alias analysis pass
that was flow and context insensitive. This analysis was supported by
command-line flags that allowed manual input in order to improve
interprocedural handling of alias information. With the addition of
an interprocedural points-to analyzer to Cetus, the default for
generating alias information is via the result provided by points-to
analysis. Changes are reflected in the update to input flags outlined
above. The API for accessing alias information via the analysis pass
remains the same, and provides results whose accuracy is based on that
provided by the points-to analyzer.
* Automatic Parallelization updates
1. Improved alias information
As outlined above, advanced interprocedural points-to analysis is used
to provide more accurate 'statement-specific' alias information. This
is used to its advantage by the dependence analysis framework, thus
increasing the chances of disambiguation via alias information. The
result is a significant increase in the number of loops identified by
Cetus as parallel.
2. Field access disambiguation
Cetus handles scalar dependences through the information provided by
the privatization and reduction analysis passes. This release of
Cetus handles disambiguation of fields inside aggregate structures
more accurately, thus providing better loop parallelization.
3. Parallelization results
Automatic interprocedural alias information significantly improves
parallelization capabilities of Cetus. This is reflected strongly
in the number of loops automatically parallelized using the Cetus
infrastructure.
* Normalize Return Statements
This pass is a simple transformation added to this release of Cetus
in order to normalize return statements inside procedures. This
transformation simplifies one or more return statements inside the
procedure by introducing a return variable. All expressions inside
a return statement are then moved to an assignment to the new
variable before the return statement. This ensures a simple
return statement that does not modify program state and
is specifically used in the interprocedural points-to analyzer in
this release. NOTE: This transformation is different from the
pre-existing SingleReturn pass in Cetus.
* Deprecated features
- cetus.analysis.NormalExpression - replaced by cetus.hir.Symbolic
- cetus.hir.Simplifier - obsolete
- cetus.hir.Tools - separated into five classes (see above)
* OpenMP-to-CUDA Translation
This release includes the alpha version of OpenMP-to-CUDA translator,
which is built on top of Cetus compiler infrastructure. The current version
of the translator is invoked separately with a customized driver, but we
envision a Cetus driver that invokes the translator as one of translation
passes in a future release.
More information can be found in readme.omp2gpu file.
CONTENTS
--------
This Cetus release has the following contents.
src - Cetus source code
lib - Archived classes (jar)
api - JAVA documents
build.sh - Command line build script
build.xml - Build configuration for Apache Ant
readme - this file
readme.omp2gpu - readme file for OpenMP-to-CUDA translator
license - Cetus license
REQUIREMENTS
------------
* JAVA 2 SDK, SE 1.5.x (or later)
* ANTLRv2
* GCC
INSTALLATION
------------
* Obtain Cetus distribution
The latest version of Cetus can be obtained at:
http://cetus.ecn.purdue.edu/
* Unpack
Users need to unpack the distribution before installing Cetus.
$ cd <directory_where_cetus.tar.gz_exists>
$ gzip -d cetus.tar.gz | tar xvf -
* Build
There are several options for building Cetus:
- For Apache Ant users
The provided build.xml defines the build targets for Cetus. The available
targets are "compile", "jar", "clean" and "javadoc". Users need to edit
the location of the Antlr tool.
- For Linux/Unix command line users.
Run the script build.sh after defining system-dependent variables in the
script.
- For SDK (Eclipse, Netbeans, etc) users
Follow the instructions of each SDK.
RUNNING CETUS
-------------
Users can run Cetus in the following ways:
$ java -classpath=<user_class_path> cetus.exec.Driver <options> <C files>
The "user_class_path" should include the class paths of Antlr and Cetus.
"build.sh" and "build.xml" provides a target that generates a wrapper script
for Cetus users.
TESTING
-------
We have tested Cetus successfully using the following benchmark suites:
* SPECCPU2006
More information about this suite available at www.spec.org
* SPECOMP2001
More information about this suite available at www.spec.org
* NPB3.0
More information about NAS Parallel Benchmarks at www.nas.nasa.gov/Software/NPB/
September 10, 2010
The Cetus Team
URL: http://cetus.ecn.purdue.edu
EMAIL: cetus@ecn.purdue.edu
RELEASE
--------
Cetus 1.1 (July 10, 2009)
Cetus is a source-to-source compiler infrastructure for C written in Java.
http://cetus.ecn.purdue.edu
FEATURES/UPDATES
----------------
* Bug fixes
- Illegal identifiers from parsing unnamed structs
The previous version used the file name as the prefix for unnamed structs
allowing struct names that start with numeric characters. The current
version adds a fixed head "named_" before the original name and handles
such cases safely.
- Fixed bugs in the following transformation passes
-tsingle-declarator
-tsingle-return
-normalize
* New flags
-argument-noalias
Specifies that arguments (parameters) don't alias each other but may alias
global storage
-argument-noalias-global
Specifies that arguments (parameters) don't alias each other and don't
alias global storage
-loop-interchange
Interchange loop to improve locality
-macro
Sets macros for the specified names with comma-separated list (no space is
allowed). e.g., -macro=ARCH=i686,OS=linux
-no-side-effect
Assume there is no side-effect in the function calls (for range analysis)
-profile-loops
Inserts loop profiling calls (1=every, 2=outer, 3=cetus parallel, 4=outer
cetus parallel, 5=openmp 6=outer openmp)
* Removed flags
-antlr : default behavior
-parse-only: default behavior
-usage : default behavior
-cfg : no support
-inline=N : no support
-openmp : no support
-procs=N : no support
-tloops-to-subroutine: no support
* Experimental flags
-tsingle-call
It is not stable for now. Contact the cetus developers for support.
* Improved symbolic tools
The accuracy of the symbolic range analysis was improved substantially and
it provides tighter bounds of integer variables used as index variables than
the previous version does. We have also improved the symbolic expression
comparator so that it handles complex expressions such as division
expressions.
We also provide a new set of simplification utilities in
"cetus.hir.Symbolic" which is cleaner and efficient compared to the
existing one in "cetus.analysis.NormalExpression". It is backward-compatible
with "NormalExpression", so users can safely switch to "Symbolic". The
following methods are commonly used features:
- Symbolic.simplify(e) : simplifies the given expression e
- Symbolic.add(e1, e2) : performs e1+e2 followed by simplification
- Symbolic.multiply(e1, e2): performs e1*e2 followed by simplification
- Symbolic.subtract(e1, e2): performs e1-e2 followed by simplification
- Symbolic.divide(e1, e2) : performs e1/e2 followed by simplification
* Annotations
The new version of Cetus extends our initial implementation of Annotations
to a completely new IR structure and API. Comments, pragmas and other
annotations were initially parsed in as Annotations and enclosed inside
DeclarationStatements (in most cases).
In the new implementation, parsed in annotations are converted to a new
internal representation through the AnnotationParser. The AnnotationParser
stores annotations under corresponding subclasses:
- PragmaAnnotation
- CetusAnnotation (#pragma cetus ...)
- OmpAnnotation (#pragma omp ...)
- CommentAnnotation (e.g. /* ... */)
- CodeAnnotation (Raw printing)
Annotations are stored as member objects of "Annotatable" IR (Statements
and Declarations), the new API for manipulating these is hence available
through Annotatable. Standalone annotations are enclosed in special IR
such as AnnotationDeclaration or AnnotationStatement (note that
AnnotationStatement is different from previous release).
The API in Annotatable *COMPLETELY REPLACES* previous functionality
provided through Tools.java. We understand this can require substantial
updates for Cetus users, but we believe the new representation is much
cleaner and warrants a small amount of time required to port over to the
new release.
* Automatic Parallelization updates:
1. Improved symbolic handling by Banerjee test
The DDTDriver framework now uses symbolic information through range analysis
in order to simplify symbolic subscripts and symbolic values associated with
loop bounds and increments. This information enhances the data dependence
results provided by the Banerjee-Wolfe inequalities leading to better
parallelization results.
2. Nonperfect loop nest handling
The DDT and parallelization frameworks now support testing for parallel
loops in non-perfect nests by using common enclosing loop information
and accommodating variable length direction vectors during
parallelization.
3. Improved function call handling inside of loops
The DDT framework can now handle system calls inside of loops that are
known to have no side effects. This is currently a fixed list of functions
that includes log(), sqrt(), fabs() and possibly other calls
encountered in parallelizable loops in our benchmarks. Future releases
will allow this list to be extended. If you are aware of a parallelizable
function call within your application, it can be easily added to this
list. Look for details in LoopTools.java
The framework also uses simple interprocedural side-effect analysis in
order to determine eligible loops for parallelization.
4. Interface to Data Dependence Graph
A more efficient and convenient implementation of the Data Dependence graph
is used in this version of Cetus. The dependence graph is created once and
attached to the Program IR object for use by other passes. A reference to this
DDGraph object gives access to the dependence information API provided by
DDGraph. The DDGraph implementation and API provided in Cetus v1.0 have been
deprecated.
5. Induction variable substitution pass
We provide a fully working induction variable substitution pass which was
experimental before. It was designed to support "Generalized Inudction
Variables" that may increase multiple times in multiply nested loops. We use
aggressive symbolic manipulators for this transformation pass to maximize
the coverage of the transformation and the subsequent loop parallelizer.
The capability of the IV substitution pass is illustrated in the example code
for the range test below.
6. Non-linear and symbolic data dependence test (Range Test)
We ported the powerful non-linear and symbolic DD test, "Range Test", which
was implemented in the Polaris parallelizing compiler for Fortran programs.
The test disproves dependences based on the "overlap" checking which compares
extreme values of subscripts for the whole loop or between two consecutive
iterations in conjunction with the monotonicity properties of the subscripts.
It works seamlessly with the data dependence framework in Cetus, and users
can turn on the range test by specifying the flag "-ddt=3".
The following example highlights the capability of the range test when
parallelizing the given loop in conjunction with the induction variable
substitution pass:
k = 0; k = 0;
for (i=0; i<10; i++) { #pragma omp parallel for private(i)
k = k+i; --> for (i=0; i<imax; i++) {
a[k] = ...; a[(i+i*i)/2] = ...;
} }
7. Improved parallelization results
The above updates have led to significant improvement in automatic
parallelization results using Cetus. You can refer to our latest
Cetus tutorial at http://cetus.ecn.purdue.edu for detailed
information.
CONTENTS
--------
This Cetus release has the following contents.
src - Source codes of Cetus
lib - Archived classes (jar)
api - JAVA documents
build.sh - Command line build script
build.xml - Build configuration for Apache Ant
readme - this file
license - Cetus license
REQUIREMENTS
------------
* JAVA 2 SDK, SE 1.5.x (or later)
* ANTLRv2
* GCC
INSTALLATION
------------
* Obtain Cetus distribution
The latest version of Cetus can be obtained at:
http://cetus.ecn.purdue.edu/
* Unpack
Users need to unpack the distribution before installing Cetus.
$ cd <directory_where_cetus.tar.gz_exists>
$ gzip -d cetus.tar.gz | tar xvf -
* Build
There are several options for building Cetus:
- For Apache Ant users
The provided build.xml defines the build targets for Cetus. The available
targets are "compile", "jar", "clean" and "javadoc". Users need to edit
the location of the Antlr tool.
- For Linux/Unix command line users.
Run the script build.sh after defining system-dependent variables in the
script.
- For SDK (Eclipse, Netbeans, etc) users
Follow the instructions of each SDK.
RUNNING CETUS
-------------
Users can run Cetus in the following ways:
$ java -classpath=<user_class_path> cetus.exec.Driver <options> <c codes>
The "user_class_path" should include the class paths of Antlr and Cetus.
"build.sh" and "build.xml" provides a target that generates a wrapper script
for Cetus users.
TESTING
-------
We have tested Cetus successfully using the following benchmark suites: