January 2006 - Projects

[genericity-support-comparison] Add benches
by Didier Verna 09 Jan '06

09 Jan '06

NOTE: This patch has been committed. The version below is informational only (whitespace differences have been removed). ChangeLog addition: 2006-01-09 Didier Verna <didier(a)lrde.epita.fr> * 2.0/src/dd/cl/tsi.cl: Fix size and nsteps parameters. * 2.0/txt/bench.didier: New. GSC source patch: Diff command: svn diff --diff-cmd /usr/bin/diff -x "-u -t -b -B -w" Files affected: 2.0/src/dd/cl/tsi.cl 2.0/txt/bench.didier Index: 2.0/txt/bench.didier =================================================================== --- 2.0/txt/bench.didier (revision 0) +++ 2.0/txt/bench.didier (revision 0) @@ -0,0 +1,331 @@ + BENCHMARKS RESULTS + + +* Architecture + +Debian unstable. + +** uname -a + +Linux uzeb 2.4.27-2-686-smp #1 SMP Wed Nov 30 21:47:06 JST 2005 i686 GNU/Linux + +Note the SMP flag: the CPU has hyperthreading turned on; the OS sees two +virtual processors. + +** cat /proc/cpuinfo + +processor : 0 +vendor_id : GenuineIntel +cpu family : 15 +model : 3 +model name : Intel(R) Pentium(R) 4 CPU 3.00GHz +stepping : 4 +cpu MHz : 2992.789 +cache size : 1024 KB +fdiv_bug : no +hlt_bug : no +f00f_bug : no +coma_bug : no +fpu : yes +fpu_exception : yes +cpuid level : 5 +wp : yes +flags : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush dts acpi mmx fxsr sse sse2 ss ht tm pbe pni monitor ds_cpl cid +bogomips : 5976.88 + +processor : 1 +vendor_id : GenuineIntel +cpu family : 15 +model : 3 +model name : Intel(R) Pentium(R) 4 CPU 3.00GHz +stepping : 4 +cpu MHz : 2992.789 +cache size : 1024 KB +fdiv_bug : no +hlt_bug : no +f00f_bug : no +coma_bug : no +fpu : yes +fpu_exception : yes +cpuid level : 5 +wp : yes +flags : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush dts acpi mmx fxsr sse sse2 ss ht tm pbe pni monitor ds_cpl cid +bogomips : 5976.88 + + + +* Benchmarks + +** Environment + +*** C + +gcc (GCC) 4.0.3 20051201 (prerelease) (Debian 4.0.2-5) +Copyright (C) 2005 Free Software Foundation, Inc. +This is free software; see the source for copying conditions. There is NO +warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + +gcc -03 -DNDEBUG + +*** Java + +java version "1.5.0_06" +Java(TM) 2 Runtime Environment, Standard Edition (build 1.5.0_06-b05) +Java HotSpot(TM) Client VM (build 1.5.0_06-b05, mixed mode, sharing) + +javac: idem + +*** Eiffel + +SmartEiffel The GNU Eiffel Compiler, Eiffel tools and libraries +Release 1.1 Release (Monday June 16th 2003) [Charlemagne] +Copyright (C), 1994-2003 - INRIA - LORIA - UHP - Nancy 2 - FRANCE +D.COLNET, S.COLLIN, O.ZENDRA, P.RIBET, C.ADRIAN - SmartEiffel(a)loria.fr +http://SmartEiffel.loria.fr + +compile_to_c -boost / then C compilation + +*** Common Lisp + +XEmacs / Slime / CMU-CL + +CMU Common Lisp CVS 19c 19c-release + minimal debian patches (19C), running on +uzeb With core: /usr/lib/cmucl/lisp.core +Dumped on: Mon, 2005-12-12 10:05:58+01:00 on uzeb + +Loaded subsystems: + Python 1.1, target Intel x86 + CLOS based on Gerd's PCL 2004/04/14 03:32:47 + + +** Dedicated versions + +*** C + +Linear / 800x800 / 200 steps: +SB: 0.31 +MB: 0.33 + +Randomized / 800x800 / 200 steps: +SB: 10.82 +MB: 8.86 + + +*** Java + +Linear / 800x800 / 200 steps: +SB: 0.35 +MB: 0.57 + +Randomized / 800x800 / 200 steps: +SB: 11.00 +MB: 9.10 + + +*** Eiffel + +Linear / 800x800 / 200 steps: +SB: 0.40 +MB: 1.06 + +Randomized / 800x800 / 200 steps: +SB: 11.04 +MB: 9.00 + +*** Common Lisp + +;;; Optimized benches for 200 step(s): +;; Linear / Untyped / Multibuffer: +; Evaluation took: +; 2.48 seconds of real time +; 2.49 seconds of user run time +; 0.0 seconds of system run time +; 7,429,347,345 CPU cycles +; 0 page faults and +; 0 bytes consed. +; +;; Linear / Untyped / Singlebuffer / AREF: +; Evaluation took: +; 1.32 seconds of real time +; 1.29 seconds of user run time +; 0.02 seconds of system run time +; 3,949,483,710 CPU cycles +; 0 page faults and +; 0 bytes consed. +; +;; Linear / Untyped / Singlebuffer / SVREF: +; Evaluation took: +; 1.12 seconds of real time +; 1.11 seconds of user run time +; 0.0 seconds of system run time +; 3,345,343,913 CPU cycles +; 0 page faults and +; 0 bytes consed. +; + +;;; Optimized benches for 200 step(s): +;; Randomized / Untyped / Multibuffer: +; Evaluation took: +; 42.61 seconds of real time +; 42.55 seconds of user run time +; 0.0 seconds of system run time +; 127,510,882,845 CPU cycles +; 0 page faults and +; 0 bytes consed. +; +;; Randomized / Untyped / Singlebuffer / AREF: +; Evaluation took: +; 38.69 seconds of real time +; 38.66 seconds of user run time +; 0.01 seconds of system run time +; 115,775,643,570 CPU cycles +; 0 page faults and +; 0 bytes consed. +; +;; Randomized / Untyped / Singlebuffer / SVREF: +; Evaluation took: +; 38.76 seconds of real time +; 38.63 seconds of user run time +; 0.11 seconds of system run time +; 116,005,607,213 CPU cycles +; 0 page faults and +; 0 bytes consed. +; + +;;; Optimized benches for 200 step(s): +;; Linear / Typed / Multibuffer: +; Evaluation took: +; 2.82 seconds of real time +; 2.83 seconds of user run time +; 0.0 seconds of system run time +; 8,467,002,300 CPU cycles +; 0 page faults and +; 0 bytes consed. +; +;; Linear / Typed / Singlebuffer / AREF: +; Evaluation took: +; 0.55 seconds of real time +; 0.55 seconds of user run time +; 0.0 seconds of system run time +; 1,636,237,845 CPU cycles +; 0 page faults and +; 0 bytes consed. +; +;; Linear / Typed / Singlebuffer / SVREF: +; Evaluation took: +; 0.55 seconds of real time +; 0.52 seconds of user run time +; 0.03 seconds of system run time +; 1,651,320,795 CPU cycles +; 0 page faults and +; 0 bytes consed. +; + +;;; Optimized benches for 200 step(s): +;; Randomized / Typed / Multibuffer: +; Evaluation took: +; 28.21 seconds of real time +; 28.18 seconds of user run time +; 0.03 seconds of system run time +; 84,420,916,523 CPU cycles +; 0 page faults and +; 0 bytes consed. +; +;; Randomized / Typed / Singlebuffer / AREF: +; Evaluation took: +; 18.4 seconds of real time +; 18.37 seconds of user run time +; 0.01 seconds of system run time +; 55,038,771,285 CPU cycles +; 0 page faults and +; 0 bytes consed. +; +;; Randomized / Typed / Singlebuffer / SVREF: +; Evaluation took: +; 19.32 seconds of real time +; 19.16 seconds of user run time +; 0.04 seconds of system run time +; 57,815,967,854 CPU cycles +; 0 page faults and +; 0 bytes consed. +; + +;;; Optimized benches for 200 step(s): +;; Linear / Typed / Sized / Multibuffer: +; Evaluation took: +; 1.09 seconds of real time +; 1.09 seconds of user run time +; 0.01 seconds of system run time +; 3,289,851,878 CPU cycles +; 0 page faults and +; 0 bytes consed. +; +;; Linear / Typed / Sized / Singlebuffer / AREF: +; Evaluation took: +; 0.54 seconds of real time +; 0.53 seconds of user run time +; 0.01 seconds of system run time +; 1,613,471,783 CPU cycles +; 0 page faults and +; 0 bytes consed. +; +;; Linear / Typed / Sized / Singlebuffer / SVREF: +; Evaluation took: +; 0.55 seconds of real time +; 0.55 seconds of user run time +; 0.0 seconds of system run time +; 1,659,704,692 CPU cycles +; 0 page faults and +; 0 bytes consed. +; + +;;; Optimized benches for 200 step(s): +;; Randomized / Typed / Sized / Multibuffer: +; Evaluation took: +; 22.03 seconds of real time +; 22.02 seconds of user run time +; 0.01 seconds of system run time +; 65,924,021,535 CPU cycles +; 0 page faults and +; 0 bytes consed. +; +;; Randomized / Typed / Sized / Singlebuffer / AREF: +; Evaluation took: +; 19.19 seconds of real time +; 19.16 seconds of user run time +; 0.02 seconds of system run time +; 57,427,619,017 CPU cycles +; 0 page faults and +; 0 bytes consed. +; +;; Randomized / Typed / Sized / Singlebuffer / SVREF: +; Evaluation took: +; 19.22 seconds of real time +; 19.17 seconds of user run time +; 0.08 seconds of system run time +; 57,512,349,082 CPU cycles +; 0 page faults and +; 0 bytes consed. +; + + +*** Summary + + Linear Randomized +C 0.31 - 0.33 10.82 - 8.86 +Java 0.35 - 0.57 11.00 - 9.10 +Eiffel 0.40 - 1.06 11.04 - 9.00 +Commom Lisp 0.55 - 1.10 18.38 - 22.03 + +Note for Common Lisp: the best MB version is the sized one, and makes a big +difference. The best randomized MB version is also the sized one. + +Single buffer versions: randomized time ~ 30 * linear time +Multi buffer versions: randomized time ~ 20 * linear time + + + + +Local Variables: +mode: outline +End: Index: 2.0/src/dd/cl/tsi.cl =================================================================== --- 2.0/src/dd/cl/tsi.cl (revision 46) +++ 2.0/src/dd/cl/tsi.cl (working copy) @@ -17,10 +17,10 @@ "Prime number to randomize memory access.") (eval-when (:compile-toplevel :load-toplevel :execute) - (defvar *size* 1024 + (defvar *size* 800 "Dimension for (square) images.")) -(defvar *nsteps* 100 +(defvar *nsteps* 200 "Number of times to repeat the algorithm.") -- Didier Verna, didier(a)lrde.epita.fr, http://www.lrde.epita.fr/~didier EPITA / LRDE, 14-16 rue Voltaire Tel.+33 (1) 44 08 01 85 94276 Le Kremlin-Bicêtre, France Fax.+33 (1) 53 14 59 22 didier(a)xemacs.org

1 0

[genericity-support-comparison] Add some Makefiles
by Didier Verna 09 Jan '06

09 Jan '06

NOTE: This patch has been committed. The version below is informational only (whitespace differences have been removed). ChangeLog addition: 2006-01-09 Didier Verna <didier(a)lrde.epita.fr> * 2.0/src/dd/eiffel/Makefile: New. * 2.0/src/dd/java/Makefile: Ditto. * 2.0/src/dd/c/Makefile: Ditto. GSC source patch: Diff command: svn diff --diff-cmd /usr/bin/diff -x "-u -t -b -B -w" Files affected: 2.0/src/dd/eiffel/Makefile 2.0/src/dd/java/Makefile 2.0/src/dd/c/Makefile Index: 2.0/src/dd/c/Makefile =================================================================== --- 2.0/src/dd/c/Makefile (revision 0) +++ 2.0/src/dd/c/Makefile (revision 0) @@ -0,0 +1,5 @@ +CC = gcc +CPPFLAGS = -DNDEBUG +CFLAGS = -O3 + +all: dd_c dd_ci Index: 2.0/src/dd/java/Makefile =================================================================== --- 2.0/src/dd/java/Makefile (revision 0) +++ 2.0/src/dd/java/Makefile (revision 0) @@ -0,0 +1,4 @@ +all: Main.class MainI.class + +%.class: %.java + javac $< Index: 2.0/src/dd/eiffel/Makefile =================================================================== --- 2.0/src/dd/eiffel/Makefile (revision 0) +++ 2.0/src/dd/eiffel/Makefile (revision 0) @@ -0,0 +1,14 @@ +CC = gcc +CPPFLAGS = -DNDEBUG +CFLAGS = -O3 + +all: main1 maini1 + +main1: main1.c +maini1: maini1.c + +main1.c: main.e + compile_to_c -boost $< + +maini1.c: maini.e + compile_to_c -boost $< -- Didier Verna, didier(a)lrde.epita.fr, http://www.lrde.epita.fr/~didier EPITA / LRDE, 14-16 rue Voltaire Tel.+33 (1) 44 08 01 85 94276 Le Kremlin-Bicêtre, France Fax.+33 (1) 53 14 59 22 didier(a)xemacs.org

1 0

[genericity-support-comparison] Update README
by Didier Verna 09 Jan '06

09 Jan '06

NOTE: This patch has been committed. The version below is informational only (whitespace differences have been removed). ChangeLog addition: 2006-01-09 Didier Verna <didier(a)lrde.epita.fr> * 2.0/README: Update comments for dedicated versions. GSC source patch: Diff command: svn diff --diff-cmd /usr/bin/diff -x "-u -t -b -B -w" Files affected: 2.0/README Index: 2.0/README =================================================================== --- 2.0/README (revision 46) +++ 2.0/README (working copy) @@ -161,23 +161,32 @@ ** src/dd -dedicated code, no abstraction +*** Languages currently used: +C, Java, Eiffel, Common Lisp. -*** comments - -the C code gives us a time reference. - -*** code - -c/ - dd_c.c - -java/ - Main.java - -eiffel/ - image1d_int.e - main.e +*** Comments: +Programs are fully dedicated (no abstraction). Apart from language-specific +peculiarities, there are 4 variations of the algorithm for each language: +- images represented as one or two-dimensional arrays +- linear or "randomized" image traversal + +The linear versions simply traverse the images by line / column order. The +"randomized" versions (files ending with an 'i') are supposed to minimize the +hardware / os impact on memory access (typically, cache size, pagination etc). +To this aim, image traversal is done by column first (in 2D array versions), +and individual cells are accessed by steps of a prime number. + +Along with the same lines, the default image size (800) is chosen *not* to be +a power of two. + + +Some recommendations: +- do not use language-specific idioms (e.g. *p++ = ... in C) to avoid + potential language-specific optimization. We want to test the algorithm + only. +- do not bench on a single run of the algorithm, to avoid initalization + artefacts (like initial page faults), and timing precision influence. That's + why the default number of runs is set to 200. ** src/st -- Didier Verna, didier(a)lrde.epita.fr, http://www.lrde.epita.fr/~didier EPITA / LRDE, 14-16 rue Voltaire Tel.+33 (1) 44 08 01 85 94276 Le Kremlin-Bicêtre, France Fax.+33 (1) 53 14 59 22 didier(a)xemacs.org

1 0

[genericity-support-comparison] Add Common Lisp dedicated version
by Didier Verna 09 Jan '06

09 Jan '06

NOTE: This patch has been committed. The version below is informational only (whitespace differences have been removed). ../ChangeLog addition: 2006-01-09 Didier Verna <didier(a)lrde.epita.fr> Add Common Lisp dedicated versions: * 2.0/src/dd/cl/u.cl: New (untyped version). * 2.0/src/dd/cl/t.cl: New (typed version). * 2.0/src/dd/cl/ts.cl: New (typed and sized version). Randomized versions of the files above: * 2.0/src/dd/cl/ui.cl: New. * 2.0/src/dd/cl/ti.cl: New. * 2.0/src/dd/cl/tsi.cl: New. GSC source patch: Diff command: svn diff --diff-cmd /usr/bin/diff -x "-u -t -b -B -w" Files affected: src/dd/cl/tsi.cl src/dd/cl/ui.cl src/dd/cl/ti.cl src/dd/cl/ts.cl src/dd/cl/u.cl src/dd/cl/t.cl Property changes on: src/dd/cl ___________________________________________________________________ Name: svn:ignore + *.x86f Index: src/dd/cl/t.cl =================================================================== --- src/dd/cl/t.cl (revision 0) +++ src/dd/cl/t.cl (revision 0) @@ -0,0 +1,103 @@ +;;; 1D Image assignation algorithm, typed version. + +(eval-when (:compile-toplevel) + (defvar *optimize* t) + (if *optimize* + (declaim (inline assign/mb assign/sb-aref assign/sb-svref) + (optimize (speed 3) + (compilation-speed 0) + (safety 0) + (debug 0))) + (declaim (optimize (speed 0) + (compilation-speed 0) + (safety 3) + (debug 0))))) + +(defvar *size* 800 + "Dimension for (square) images.") + +(defvar *nsteps* 200 + "Number of times to repeat the algorithm.") + + +;;; 1D Image, multibuffer implementation: + +(defun make-image/mb (size) + "Create a square 1D image using a 2D array." + ;; The following declaration doesn't optimize anything, since the problem is + ;; having a constant list in MAKE-ARRAY. + (declare (type fixnum size)) + (make-array (list size size) :initial-element 0 :element-type 'fixnum)) + +(defun assign/mb (image value) + "Add VALUE to every point of IMAGE (2D array implementation)." + (declare (type (simple-array fixnum) image)) + (declare (type fixnum value)) + (let ((size (array-dimension image 0))) + (dotimes (i size) + (declare (type fixnum i)) + (dotimes (j size) + ;; Surprisingly, CMU-CL requests the declaration of i to optimize, but + ;; not the following one ?? + (declare (type fixnum j)) + (setf (aref image i j) (+ (aref image i j) value)))))) + + +;;; 1D Image, singlebuffer / aref implementation: + +(defun make-image/sb-aref (size) + "Create a square 1D image using a 1D array." + (declare (type fixnum size)) + (make-array (* size size) :initial-element 0 :element-type 'fixnum)) + +(defun assign/sb-aref (image value) + "Add VALUE to every point of IMAGE (1D array implementation)." + (declare (type (simple-array fixnum) image)) + (declare (type fixnum value)) + (let ((size (array-dimension image 0))) + (dotimes (i size) + (setf (aref image i) (+ (aref image i) value))))) + + +;;; 1D Image, singlebuffer / svref implementation: + +(defun make-image/sb-svref (size) + "Create a square 1D image using a simple-vector." + (declare (type fixnum size)) + ;; Don't specify a type here. We're using the simple-vector approach. + (make-array (* size size) :initial-element 0)) + +(defun assign/sb-svref (image value) + "Add VALUE to every point of IMAGE (simple-vector implementation)." + (declare (type simple-vector image)) + (declare (type fixnum value)) + (let ((size (array-dimension image 0))) + (dotimes (i size) + (setf (the fixnum (svref image i)) + (+ (the fixnum (svref image i)) value))))) + + +;;; Entry point: + +(defun bench () + (let ((value 51)) + (format t ";;; ~Aptimized benches for ~D step(s):~&" + (if *optimize* "O" "Not o") *nsteps*) + (format t ";; Linear / Typed / Multibuffer:") + (let ((image (make-image/mb *size*))) + (time + (dotimes (i (the fixnum *nsteps*)) + (declare (type fixnum i)) + (assign/mb image value)))) + (format t ";; Linear / Typed / Singlebuffer / AREF:") + (let ((image (make-image/sb-aref *size*))) + (time + (dotimes (i (the fixnum *nsteps*)) + (declare (type fixnum i)) + (assign/sb-aref image value)))) + (format t ";; Linear / Typed / Singlebuffer / SVREF:") + (let ((image (make-image/sb-svref *size*))) + (time + (dotimes (i (the fixnum *nsteps*)) + (declare (type fixnum i)) + (assign/sb-svref image value)))))) Index: src/dd/cl/u.cl =================================================================== --- src/dd/cl/u.cl (revision 0) +++ src/dd/cl/u.cl (revision 0) @@ -0,0 +1,83 @@ +;;; 1D Image assignation algorithm, untyped version. + +(eval-when (:compile-toplevel) + (defvar *optimize* t) + (if *optimize* + (declaim (inline assign/mb assign/sb-aref assign/sb-svref) + (optimize (speed 3) + (compilation-speed 0) + (safety 0) + (debug 0))) + (declaim (optimize (speed 0) + (compilation-speed 0) + (safety 3) + (debug 0))))) + +(defvar *size* 800 + "Dimension for (square) images.") +(defvar *nsteps* 200 + "Number of times to repeat the algorithm.") + + +;;; 1D Image, multibuffer implementation: + +(defun make-image/mb (size) + "Create a square 1D image using a 2D array." + (make-array (list size size) :initial-element 0)) + +(defun assign/mb (image value) + "Add VALUE to every point of IMAGE (2D array implementation)." + (let ((size (array-dimension image 0))) + (dotimes (i size) + (dotimes (j size) + (setf (aref image i j) (+ (aref image i j) value)))))) + + +;;; 1D Image, singlebuffer / aref implementation: + +(defun make-image/sb-aref (size) + "Create a square 1D image using a 1D array." + (make-array (* size size) :initial-element 0)) + +(defun assign/sb-aref (image value) + "Add VALUE to every point of IMAGE (1D array implementation)." + (let ((size (array-dimension image 0))) + (dotimes (i size) + (setf (aref image i) (+ (aref image i) value))))) + + +;;; 1D Image, singlebuffer / svref implementation: + +(defun make-image/sb-svref (size) + "Create a square 1D image using a simple-vector." + (make-array (* size size) :initial-element 0)) + +(defun assign/sb-svref (image value) + "Add VALUE to every point of IMAGE (simple-vector implementation)." + (let ((size (array-dimension image 0))) + (dotimes (i size) + (setf (svref image i) (+ (svref image i) value))))) + + +;;; Entry point: + +(defun bench () + "Perform benchmarks on all implementations." + (let ((value 51)) + (format t ";;; ~Aptimized benches for ~D step(s):~&" + (if *optimize* "O" "Not o") *nsteps*) + (format t ";; Linear / Untyped / Multibuffer:") + (let ((image (make-image/mb *size*))) + (time + (dotimes (i *nsteps*) + (assign/mb image value)))) + (format t ";; Linear / Untyped / Singlebuffer / AREF:") + (let ((image (make-image/sb-aref *size*))) + (time + (dotimes (i *nsteps*) + (assign/sb-aref image value)))) + (format t ";; Linear / Untyped / Singlebuffer / SVREF:") + (let ((image (make-image/sb-svref *size*))) + (time + (dotimes (i *nsteps*) + (assign/sb-svref image value)))))) Index: src/dd/cl/ts.cl =================================================================== --- src/dd/cl/ts.cl (revision 0) +++ src/dd/cl/ts.cl (revision 0) @@ -0,0 +1,99 @@ +;;; 1D Image assignation algorithm, typed and sized version. + +(eval-when (:compile-toplevel) + (defvar *optimize* t) + (if *optimize* + (declaim (optimize (speed 3) + (compilation-speed 0) + (safety 0) + (debug 0))) + (declaim (optimize (speed 0) + (compilation-speed 0) + (safety 3) + (debug 0))))) + +(eval-when (:compile-toplevel :load-toplevel :execute) + (defvar *size* 800 + "Dimension for (square) images.")) + +(defvar *nsteps* 200 + "Number of times to repeat the algorithm.") + + +;;; 1D Image, multibuffer implementation: + +(defmacro make-image/mb (size) + "Create a square 1D image using a 2D array." + (let ((size-list (eval `(list ,size ,size)))) + `(make-array ',size-list :initial-element 0 :element-type 'fixnum))) + +(defmacro assign/mb (image value) + "Add VALUE to every point of IMAGE (2D array implementation)." + `(let ((size (array-dimension ,image 0))) + (dotimes (i size) + (declare (type fixnum i)) + (dotimes (j size) + ;; Surprisingly, CMU-CL requests the declaration of i to optimize, but + ;; not the following one ?? + (declare (type fixnum j)) + (setf (aref ,image i j) (+ (aref ,image i j) ,value)))))) + +;;; 1D Image, singlebuffer / aref implementation: + +(defmacro make-image/sb-aref (size) + "Create a square 1D image using a 1D array." + ;; Or, we could have used (the fixnum ,size) directly in MAKE-ARRAY. + `(let ((size ,size)) + (declare (type fixnum size)) + (make-array (* size size) :initial-element 0 :element-type 'fixnum))) + +(defmacro assign/sb-aref (image value) + "Add VALUE to every point of IMAGE (1D array implementation)." + `(let ((size (array-dimension ,image 0))) + (dotimes (i size) + (setf (aref ,image i) (+ (aref ,image i) ,value))))) + + +;;; 1D Image, singlebuffer / svref implementation: + +(defmacro make-image/sb-svref (size) + "Create a square 1D image using a simple-vector." + ;; Or, we could have used (the fixnum ,size) directly in MAKE-ARRAY. + `(let ((size ,size)) + (declare (type fixnum size)) + (make-array (* size size) :initial-element 0))) + +(defmacro assign/sb-svref (image value) + "Add VALUE to every point of IMAGE (simple-vector implementation)." + `(let ((size (array-dimension ,image 0))) + (dotimes (i size) + (setf (the fixnum (svref ,image i)) + (+ (the fixnum (svref ,image i)) ,value))))) + + +;;; Entry point: + +(defun bench () + "Perform benchmark on all implementations." + (let ((value 51)) + (declare (type fixnum value)) + (format t ";;; ~Aptimized benches for ~D step(s):~&" + (if *optimize* "O" "Not o") *nsteps*) + (format t ";; Linear / Typed / Sized / Multibuffer:") + (let ((image (make-image/mb *size*))) + (time + (dotimes (i (the fixnum *nsteps*)) + (declare (type fixnum i)) + (assign/mb image value)))) + (format t ";; Linear / Typed / Sized / Singlebuffer / AREF:") + (let ((image (make-image/sb-aref *size*))) + (time + (dotimes (i (the fixnum *nsteps*)) + (declare (type fixnum i)) + (assign/sb-aref image value)))) + (format t ";; Linear / Typed / Sized / Singlebuffer / SVREF:") + (let ((image (make-image/sb-svref *size*))) + (time + (dotimes (i (the fixnum *nsteps*)) + (declare (type fixnum i)) + (assign/sb-svref image value)))))) Index: src/dd/cl/ti.cl =================================================================== --- src/dd/cl/ti.cl (revision 0) +++ src/dd/cl/ti.cl (revision 0) @@ -0,0 +1,128 @@ +;;; 1D Image assignation algorithm, randomized and typed version. + +(eval-when (:compile-toplevel) + (defvar *optimize* t) + (if *optimize* + (declaim (inline assign/mb assign/sb-aref assign/sb-svref) + (optimize (speed 3) + (compilation-speed 0) + (safety 0) + (debug 0))) + (declaim (optimize (speed 0) + (compilation-speed 0) + (safety 3) + (debug 0))))) + +;; This prime number is chosen as the biggest one for which the offsets +;; increments in assign/* stay representable as a fixnum +(defconstant +offset+ 509 + "Prime number to randomize memory access.") + +(defvar *size* 800 + "Dimension for (square) images.") + +(defvar *nsteps* 200 + "Number of times to repeat the algorithm.") + + +;;; 1D Image, multibuffer implementation: + +(defun make-image/mb (size) + "Create a square 1D image using a 2D array." + ;; The following declaration doesn't optimize anything, since the problem is + ;; having a constant list in MAKE-ARRAY. + (declare (type fixnum size)) + (make-array (list size size) :initial-element 0 :element-type 'fixnum)) + +(defun assign/mb (image value) + "Add VALUE to every point of IMAGE (2D array implementation)." + (declare (type (simple-array fixnum) image)) + (declare (type fixnum value)) + (let ((size (array-dimension image 0)) + (offset-i 0) + (offset-j 0) + pos-i pos-j) + (declare (type fixnum offset-i)) + (declare (type fixnum offset-j)) + (dotimes (j size) + (declare (type fixnum j)) + (setf offset-i 0 + offset-j (+ offset-j +offset+) + pos-j (rem offset-j size)) + (dotimes (i size) + ;; Surprisingly, CMU-CL requests the declaration of i to optimize, but + ;; not the following one ?? + (declare (type fixnum i)) + (setf offset-i (+ offset-i +offset+) + pos-i (rem offset-i size) + (aref image pos-i pos-j) (+ (aref image pos-i pos-j) value)))))) + + +;;; 1D Image, singlebuffer / aref implementation: + +(defun make-image/sb-aref (size) + "Create a square 1D image using a 1D array." + (declare (type fixnum size)) + (make-array (* size size) :initial-element 0 :element-type 'fixnum)) + +(defun assign/sb-aref (image value) + "Add VALUE to every point of IMAGE (1D array implementation)." + (declare (type (simple-array fixnum) image)) + (declare (type fixnum value)) + (let ((size (array-dimension image 0)) + (offset 0) + pos) + (declare (type fixnum offset)) + (dotimes (i size) + (setf offset (+ offset +offset+) + pos (rem offset size) + (aref image pos) (+ (aref image pos) value))))) + + +;;; 1D Image, singlebuffer / svref implementation: + +(defun make-image/sb-svref (size) + "Create a square 1D image using a simple-vector." + (declare (type fixnum size)) + ;; Don't specify a type here. We're using the simple-vector approach. + (make-array (* size size) :initial-element 0)) + +(defun assign/sb-svref (image value) + "Add VALUE to every point of IMAGE (simple-vector implementation)." + (declare (type simple-vector image)) + (declare (type fixnum value)) + (let ((size (array-dimension image 0)) + (offset 0) + pos) + (declare (type fixnum offset)) + (dotimes (i size) + (setf offset (+ offset +offset+) + pos (rem offset size) + (the fixnum (svref image pos)) + (+ (the fixnum (svref image pos)) value))))) + + +;;; Entry point: + +(defun bench () + (let ((value 51)) + (format t ";;; ~Aptimized benches for ~D step(s):~&" + (if *optimize* "O" "Not o") *nsteps*) + (format t ";; Randomized / Typed / Multibuffer:") + (let ((image (make-image/mb *size*))) + (time + (dotimes (i (the fixnum *nsteps*)) + (declare (type fixnum i)) + (assign/mb image value)))) + (format t ";; Randomized / Typed / Singlebuffer / AREF:") + (let ((image (make-image/sb-aref *size*))) + (time + (dotimes (i (the fixnum *nsteps*)) + (declare (type fixnum i)) + (assign/sb-aref image value)))) + (format t ";; Randomized / Typed / Singlebuffer / SVREF:") + (let ((image (make-image/sb-svref *size*))) + (time + (dotimes (i (the fixnum *nsteps*)) + (declare (type fixnum i)) + (assign/sb-svref image value)))))) Index: src/dd/cl/ui.cl =================================================================== --- src/dd/cl/ui.cl (revision 0) +++ src/dd/cl/ui.cl (revision 0) @@ -0,0 +1,104 @@ +;;; 1D Image assignation algorithm, randomized and untyped version. + +(eval-when (:compile-toplevel) + (defvar *optimize* t) + (if *optimize* + (declaim (inline assign/mb assign/sb-aref assign/sb-svref) + (optimize (speed 3) + (compilation-speed 0) + (safety 0) + (debug 0))) + (declaim (optimize (speed 0) + (compilation-speed 0) + (safety 3) + (debug 0))))) + +;; See comment in ti.cl about this prime number +(defconstant +offset+ 509 + "Prime number to randomize memory access.") + +(defvar *size* 800 + "Dimension for (square) images.") + +(defvar *nsteps* 200 + "Number of times to repeat the algorithm.") + + +;;; 1D Image, multibuffer implementation: + +(defun make-image/mb (size) + "Create a square 1D image using a 2D array." + (make-array (list size size) :initial-element 0)) + +(defun assign/mb (image value) + "Add VALUE to every point of IMAGE (2D array implementation)." + (let ((size (array-dimension image 0)) + offset-i + (offset-j 0) + pos-i pos-j) + (dotimes (j size) + (setf offset-i 0 + offset-j (+ offset-j +offset+) + pos-j (rem offset-j size)) + (dotimes (i size) + (setf offset-i (+ offset-i +offset+) + pos-i (rem offset-i size) + (aref image pos-i pos-j) (+ (aref image pos-i pos-j) value)))))) + + +;;; 1D Image, singlebuffer / aref implementation: + +(defun make-image/sb-aref (size) + "Create a square 1D image using a 1D array." + (make-array (* size size) :initial-element 0)) + +(defun assign/sb-aref (image value) + "Add VALUE to every point of IMAGE (1D array implementation)." + (let ((size (array-dimension image 0)) + (offset 0) + pos) + (dotimes (i size) + (setf offset (+ offset +offset+) + pos (rem offset size) + (aref image pos) (+ (aref image pos) value))))) + + +;;; 1D Image, singlebuffer / svref implementation: + +(defun make-image/sb-svref (size) + "Create a square 1D image using a simple-vector." + (make-array (* size size) :initial-element 0)) + +(defun assign/sb-svref (image value) + "Add VALUE to every point of IMAGE (simple-vector implementation)." + (let ((size (array-dimension image 0)) + (offset 0) + pos) + (dotimes (i size) + (setf offset (+ offset +offset+) + pos (rem offset size) + (svref image pos) (+ (svref image pos) value))))) + + +;;; Entry point: + +(defun bench () + "Perform benchmarks on all implementations." + (let ((value 51)) + (format t ";;; ~Aptimized benches for ~D step(s):~&" + (if *optimize* "O" "Not o") *nsteps*) + (format t ";; Randomized / Untyped / Multibuffer:") + (let ((image (make-image/mb *size*))) + (time + (dotimes (i *nsteps*) + (assign/mb image value)))) + (format t ";; Randomized / Untyped / Singlebuffer / AREF:") + (let ((image (make-image/sb-aref *size*))) + (time + (dotimes (i *nsteps*) + (assign/sb-aref image value)))) + (format t ";; Randomized / Untyped / Singlebuffer / SVREF:") + (let ((image (make-image/sb-svref *size*))) + (time + (dotimes (i *nsteps*) + (assign/sb-svref image value)))))) Index: src/dd/cl/tsi.cl =================================================================== --- src/dd/cl/tsi.cl (revision 0) +++ src/dd/cl/tsi.cl (revision 0) @@ -0,0 +1,124 @@ +;;; 1D Image assignation algorithm, randomized, typed and sized version. + +(eval-when (:compile-toplevel) + (defvar *optimize* t) + (if *optimize* + (declaim (optimize (speed 3) + (compilation-speed 0) + (safety 0) + (debug 0))) + (declaim (optimize (speed 0) + (compilation-speed 0) + (safety 3) + (debug 0))))) + +;; See comment in ti.cl about this prime number +(defconstant +offset+ 509 + "Prime number to randomize memory access.") + +(eval-when (:compile-toplevel :load-toplevel :execute) + (defvar *size* 1024 + "Dimension for (square) images.")) + +(defvar *nsteps* 100 + "Number of times to repeat the algorithm.") + + +;;; 1D Image, multibuffer implementation: + +(defmacro make-image/mb (size) + "Create a square 1D image using a 2D array." + (let ((size-list (eval `(list ,size ,size)))) + `(make-array ',size-list :initial-element 0 :element-type 'fixnum))) + +(defmacro assign/mb (image value) + "Add VALUE to every point of IMAGE (2D array implementation)." + `(let ((size (array-dimension ,image 0)) + (offset-i 0) + (offset-j 0) + pos-i pos-j) + (declare (type fixnum offset-i)) + (declare (type fixnum offset-j)) + (dotimes (j size) + (declare (type fixnum j)) + (setf offset-i 0 + offset-j (+ offset-j +offset+) + pos-j (rem offset-j size)) + (dotimes (i size) + ;; Surprisingly, CMU-CL requests the declaration of i to optimize, but + ;; not the following one ?? + (declare (type fixnum i)) + (setf offset-i (+ offset-i +offset+) + pos-i (rem offset-i size) + (aref ,image pos-i pos-j) (+ (aref ,image pos-i pos-j) + ,value)))))) + +;;; 1D Image, singlebuffer / aref implementation: + +(defmacro make-image/sb-aref (size) + "Create a square 1D image using a 1D array." + ;; Or, we could have used (the fixnum ,size) directly in MAKE-ARRAY. + `(let ((size ,size)) + (declare (type fixnum size)) + (make-array (* size size) :initial-element 0 :element-type 'fixnum))) + +(defmacro assign/sb-aref (image value) + "Add VALUE to every point of IMAGE (1D array implementation)." + `(let ((size (array-dimension ,image 0)) + (offset 0) + pos) + (declare (type fixnum offset)) + (dotimes (i size) + (setf offset (+ offset +offset+) + pos (rem offset size) + (aref ,image pos) (+ (aref ,image pos) ,value))))) + + +;;; 1D Image, singlebuffer / svref implementation: + +(defmacro make-image/sb-svref (size) + "Create a square 1D image using a simple-vector." + ;; Or, we could have used (the fixnum ,size) directly in MAKE-ARRAY. + `(let ((size ,size)) + (declare (type fixnum size)) + (make-array (* size size) :initial-element 0))) + +(defmacro assign/sb-svref (image value) + "Add VALUE to every point of IMAGE (simple-vector implementation)." + `(let ((size (array-dimension ,image 0)) + (offset 0) + pos) + (declare (type fixnum offset)) + (dotimes (i size) + (setf offset (+ offset +offset+) + pos (rem offset size) + (the fixnum (svref ,image pos)) (+ (the fixnum (svref ,image pos)) + ,value))))) + + +;;; Entry point: + +(defun bench () + "Perform benchmark on all implementations." + (let ((value 51)) + (declare (type fixnum value)) + (format t ";;; ~Aptimized benches for ~D step(s):~&" + (if *optimize* "O" "Not o") *nsteps*) + (format t ";; Randomized / Typed / Sized / Multibuffer:") + (let ((image (make-image/mb *size*))) + (time + (dotimes (i (the fixnum *nsteps*)) + (declare (type fixnum i)) + (assign/mb image value)))) + (format t ";; Randomized / Typed / Sized / Singlebuffer / AREF:") + (let ((image (make-image/sb-aref *size*))) + (time + (dotimes (i (the fixnum *nsteps*)) + (declare (type fixnum i)) + (assign/sb-aref image value)))) + (format t ";; Randomized / Typed / Sized / Singlebuffer / SVREF:") + (let ((image (make-image/sb-svref *size*))) + (time + (dotimes (i (the fixnum *nsteps*)) + (declare (type fixnum i)) + (assign/sb-svref image value)))))) -- Didier Verna, didier(a)lrde.epita.fr, http://www.lrde.epita.fr/~didier EPITA / LRDE, 14-16 rue Voltaire Tel.+33 (1) 44 08 01 85 94276 Le Kremlin-Bicêtre, France Fax.+33 (1) 53 14 59 22 didier(a)xemacs.org

1 0

[COMMIT] [genericity-support-comparison] Update dedicated versions
by Didier Verna 09 Jan '06

09 Jan '06

NOTE: This patch has been committed. The version below is informational only (whitespace differences have been removed). ../ChangeLog addition: 2006-01-09 Didier Verna <didier(a)lrde.epita.fr> * 2.0/src/dd/eiffel/maini.e: New (randomized access version). * 2.0/src/dd/eiffel/image_mb.e: New (multibuffer image class). * 2.0/src/dd/eiffel/image_sb.e: formerly known as image1d_int.e. * 2.0/src/dd/java/MainI.java: New (randomized access version). * 2.0/src/dd/c/dd_ci.c: See below. * 2.0/src/dd/c/dd_c.c: Ditto. * 2.0/src/dd/eiffel/main.e: Ditto. * 2.0/src/dd/java/Main.java: Ditto. Dedicated versions update: - add 2D array implementations in all languages, - add missing "randomized" versions in all languages, - add command-line arguments for size and steps, - default to 800x800 and 200 steps, - use a prime number not subject to integer overflow. GSC source patch: Diff command: svn diff --diff-cmd /usr/bin/diff -x "-u -t -b -B -w" Files affected: src/dd/eiffel/image_sb.e src/dd/eiffel/main.e src/dd/eiffel/image_mb.e src/dd/eiffel/maini.e src/dd/c/dd_c.c src/dd/c/dd_ci.c src/dd/java/MainI.java src/dd/java/Main.java Index: src/dd/java/Main.java =================================================================== --- src/dd/java/Main.java (revision 42) +++ src/dd/java/Main.java (working copy) @@ -1,15 +1,14 @@ - // compile and run with: // javac Main.java -// java -cp . Main +// java Main import java.io.*; import java.util.Timer; -class Image2d_int +class ImageSB { - public Image2d_int(int n) + public ImageSB(int n) { this.n = n; data = new int[n]; @@ -18,37 +17,71 @@ public int[] data; } +class ImageMB +{ + public ImageMB(int n) + { + this.n = n; + data = new int[n][n]; + } + public int n; + public int[][] data; +} + class Main { - public static void assign(Image2d_int ima, int val) + public static void assignSB(ImageSB ima, int val) { int n = ima.n; for (int i = 0; i < n; ++i) ima.data[i] = val; } + public static void assignMB(ImageMB ima, int val) + { + int n = ima.n; + for (int i = 0; i < n; ++i) + for (int j = 0; j < n; ++j) + ima.data[i][j] = val; + } + public static void usage() { - System.err.println("usage: java Main [nsteps = 1]"); + System.err.println("usage: java Main [size = 800] [nsteps = 200]"); } public static void main(String[] args) { - if (args.length > 1) + if (args.length > 2) { usage(); return; } - int nsteps = args.length == 0 ? 1 : Integer.parseInt(args[0]); - int size = 1024 * 1024; - Image2d_int ima = new Image2d_int(size); + int size = args.length > 0 ? Integer.parseInt(args[0]) : 800; + int nsteps = args.length > 1 ? Integer.parseInt(args[1]) : 200; int val = 51; + System.out.println("Linear / " + + size + "x" + size + " / " + + nsteps + " steps:"); + + { + ImageSB ima = new ImageSB(size * size); long t0 = System.currentTimeMillis(); for (int step = 0; step < nsteps; ++step) - assign(ima, val); - System.out.println((System.currentTimeMillis() - t0)/(double)1000); + assignSB(ima, val); + long t1 = System.currentTimeMillis(); + System.out.println("SB: " + (t1 - t0)/(double)1000); + } + { + ImageMB ima = new ImageMB(size); + long t0 = System.currentTimeMillis(); + for (int step = 0; step < nsteps; ++step) + assignMB(ima, val); + long t1 = System.currentTimeMillis(); + System.out.println("MB: " + (t1 - t0)/(double)1000); + } } } Index: src/dd/java/MainI.java =================================================================== --- src/dd/java/MainI.java (revision 0) +++ src/dd/java/MainI.java (revision 0) @@ -0,0 +1,103 @@ +// compile and run with: +// javac MainI.java +// java MainI + +import java.io.*; +import java.util.Timer; + + +class ImageSBI +{ + public ImageSBI(int n) + { + this.n = n; + data = new int[n]; + } + public int n; + public int[] data; +} + +class ImageMBI +{ + public ImageMBI(int n) + { + this.n = n; + data = new int[n][n]; + } + public int n; + public int[][] data; +} + + + +class MainI +{ + public static void assignSB(ImageSBI ima, int val) + { + int n = ima.n, offset = 0; + + for (int i = 0; i < n; ++i) + { + offset += MainI.offset; + ima.data[offset % n] = val; + } + } + + public static void assignMB(ImageMBI ima, int val) + { + int n = ima.n, offset_i, offset_j = 0; + + for (int j = 0; j < n; ++j) + { + offset_j += MainI.offset; + offset_i = 0; + + for (int i = 0; i < n; ++i) + { + offset_i += MainI.offset; + ima.data[offset_i % n][offset_j % n] = val; + } + } + } + + public static void usage() + { + System.err.println("usage: java MainI [size = 800] [nsteps = 200]"); + } + + public static void main(String[] args) + { + if (args.length > 2) + { + usage(); + return; + } + int size = args.length > 0 ? Integer.parseInt(args[0]) : 800; + int nsteps = args.length > 1 ? Integer.parseInt(args[1]) : 200; + int val = 51; + + System.out.println("Randomized / " + + size + "x" + size + " / " + + nsteps + " steps:"); + + { + ImageSBI ima = new ImageSBI(size * size); + long t0 = System.currentTimeMillis(); + for (int step = 0; step < nsteps; ++step) + assignSB(ima, val); + long t1 = System.currentTimeMillis(); + System.out.println("SB: " + (t1 - t0)/(double)1000); + } + { + ImageMBI ima = new ImageMBI(size); + long t0 = System.currentTimeMillis(); + for (int step = 0; step < nsteps; ++step) + assignMB(ima, val); + long t1 = System.currentTimeMillis(); + System.out.println("MB: " + (t1 - t0)/(double)1000); + } + } + + // see comment in file ../cl/ti.cl + public static int offset = 509; +} Index: src/dd/c/dd_ci.c =================================================================== --- src/dd/c/dd_ci.c (revision 42) +++ src/dd/c/dd_ci.c (working copy) @@ -2,37 +2,129 @@ #include <stdlib.h> #include <time.h> - +/* see comment in file ../cl/ti.cl */ +#define OFFSET 509 typedef struct { - unsigned n; + int n; int* data; } -image1d_int; + image_sb; + +typedef struct +{ + int n; + int** data; +} + image_mb; + + + +image_sb* new_image_sb (int n) +{ + image_sb* ima; + + ima = (image_sb*) malloc (sizeof (image_sb)); + if (ima == NULL) + { + perror ("malloc"); + exit (1); + } + + ima->n = n; + + ima->data = (int*) calloc (n, sizeof (int)); + if (ima->data == NULL) + { + perror ("calloc"); + exit (1); + } + + return ima; +} + +void free_image_sb (image_sb* ima) +{ + free (ima->data); + free (ima); +} + + +image_mb* new_image_mb (int n) +{ + image_mb* ima; + int i; + + ima = (image_mb*) malloc (sizeof (image_mb)); + if (ima == NULL) + { + perror ("malloc"); + exit (1); + } + ima->n = n; + ima->data = (int**) calloc (n, sizeof (int*)); + if (ima->data == NULL) + { + perror ("calloc"); + exit (1); + } -image1d_int* new_image1d_int(unsigned n) + for (i = 0; i < n; ++i) { - image1d_int* this; - this = (image1d_int*)malloc(1 * sizeof(image1d_int)); - this->n = n; - this->data = (int*)malloc(n * sizeof(int)); - return this; + ima->data[i] = (int*) calloc (n, sizeof (int)); + if (ima->data[i] == NULL) + { + perror ("calloc"); + exit (1); } + } + + return ima; +} + +void free_image_mb (image_mb* ima) +{ + int i; + const int n = ima->n; + + for (i = 0; i < n; ++i) + free (ima->data[i]); + free (ima->data); + free (ima); +} + +void assign_sb (image_sb* ima, int val) +{ + int i, offset = 0; + const int n = ima->n; + + for (i = 0; i < n; ++i) + { + offset += OFFSET; + ima->data[offset % n] = val; + } +} +void assign_mb (image_mb* ima, int val) +{ + int i, j, offset_i, offset_j = 0; + const int n = ima->n; -void assign(image1d_int* ima, int val) + for (j = 0; j < n; ++j) { - unsigned i, offset = 0; - const unsigned n = ima->n; - int* p = ima->data; + offset_j += OFFSET; + offset_i = 0; + for (i = 0; i < n; ++i) { - offset += 999983; - *(p + offset % n) = val; + offset_i += OFFSET; + + ima->data[offset_i % n][offset_j % n] = val; + } } } @@ -40,30 +132,41 @@ void usage(char* argv[]) { - printf("usage: %s [size = 1024] [nsteps = 1]\n", argv[0]); + printf ("usage: %s [size = 800] [nsteps = 200]\n", argv[0]); exit(1); } int main(int argc, char* argv[]) { - image1d_int* ima; - unsigned size, step, nsteps; + image_sb* ima_sb; + image_mb* ima_mb; + int size, step, nsteps; float t0; int val; - int i = 0; if (argc > 3) usage(argv); - size = argc > 1 ? atoi(argv[1]) : 1024; - nsteps = argc > 2 ? atoi(argv[2]) : 1; + size = argc > 1 ? atoi (argv[1]) : 800; + nsteps = argc > 2 ? atoi (argv[2]) : 200; - ima = new_image1d_int(size * size); val = 51; + printf ("Randomized / %dx%d / %d steps:\n", size, size, nsteps); + + ima_sb = new_image_sb (size * size); t0 = (float)clock(); for (step = 0; step < nsteps; ++step) - assign(ima, val); - printf("%f\n", (clock() - t0) / CLOCKS_PER_SEC); + assign_sb (ima_sb, val); + printf ("SB: %f\n", (clock() - t0) / CLOCKS_PER_SEC); + free_image_sb (ima_sb); + + ima_mb = new_image_mb (size); + t0 = (float) clock (); + for (step = 0; step < nsteps; ++step) + assign_mb (ima_mb, val); + printf ("MB: %f\n", (clock() - t0) / CLOCKS_PER_SEC); + free_image_mb (ima_mb); + return 0; } Index: src/dd/c/dd_c.c =================================================================== --- src/dd/c/dd_c.c (revision 42) +++ src/dd/c/dd_c.c (working copy) @@ -6,60 +6,154 @@ typedef struct { - unsigned n; + int n; int* data; } -image1d_int; + image_sb; + +typedef struct +{ + int n; + int** data; +} + image_mb; -image1d_int* new_image1d_int(unsigned n) +image_sb* new_image_sb (int n) { - image1d_int* this; - this = (image1d_int*)malloc(1 * sizeof(image1d_int)); - this->n = n; - this->data = (int*)malloc(n * sizeof(int)); - return this; + image_sb* ima; + + ima = (image_sb*) malloc (sizeof (image_sb)); + if (ima == NULL) + { + perror ("malloc"); + exit (1); } + ima->n = n; + ima->data = (int*) calloc (n, sizeof (int)); + if (ima->data == NULL) + { + perror ("calloc"); + exit (1); + } -void assign(image1d_int* ima, int val) + return ima; +} + +void free_image_sb (image_sb* ima) { - unsigned i; - const unsigned n = ima->n; - int* p = ima->data; + free (ima->data); + free (ima); +} + + +image_mb* new_image_mb (int n) +{ + image_mb* ima; + int i; + + ima = (image_mb*) malloc (sizeof (image_mb)); + if (ima == NULL) + { + perror ("malloc"); + exit (1); + } + + ima->n = n; + + ima->data = (int**) calloc (n, sizeof (int*)); + if (ima->data == NULL) + { + perror ("calloc"); + exit (1); + } + for (i = 0; i < n; ++i) - *p++ = val; + { + ima->data[i] = (int*) calloc (n, sizeof (int)); + if (ima->data[i] == NULL) + { + perror ("calloc"); + exit (1); + } + } + + return ima; +} + +void free_image_mb (image_mb* ima) +{ + int i; + const int n = ima->n; + + for (i = 0; i < n; ++i) + free (ima->data[i]); + free (ima->data); + free (ima); +} + + +void assign_sb (image_sb* ima, int val) +{ + int i; + const int n = ima->n; + + for (i = 0; i < n; ++i) + ima->data[i] = val; +} + +void assign_mb (image_mb* ima, int val) +{ + int i, j; + const int n = ima->n; + + for (i = 0; i < n; ++i) + for (j = 0; j < n; ++j) + ima->data[i][j] = val; } void usage(char* argv[]) { - printf("usage: %s [nsteps = 1]\n", argv[0]); + printf ("usage: %s [size = 800] [nsteps = 200]\n", argv[0]); exit(1); } int main(int argc, char* argv[]) { - image1d_int* ima; - const unsigned size = 1024 * 1024; - unsigned step, nsteps; + image_sb* ima_sb; + image_mb* ima_mb; + int size, step, nsteps; float t0; int val; - if (argc > 2) + if (argc > 3) usage(argv); - nsteps = argc == 2 ? atoi(argv[1]) : 1; + size = argc > 1 ? atoi (argv[1]) : 800; + nsteps = argc > 2 ? atoi (argv[2]) : 200; - ima = new_image1d_int(size); val = 51; + printf ("Linear / %dx%d / %d steps:\n", size, size, nsteps); + + ima_sb = new_image_sb (size * size); + t0 = (float) clock (); + for (step = 0; step < nsteps; ++step) + assign_sb (ima_sb, val); + printf ("SB: %f\n", (clock() - t0) / CLOCKS_PER_SEC); + free_image_sb (ima_sb); + + ima_mb = new_image_mb (size); t0 = (float)clock(); for (step = 0; step < nsteps; ++step) - assign(ima, val); - printf("%f\n", (clock() - t0) / CLOCKS_PER_SEC); + assign_mb (ima_mb, val); + printf ("MB: %f\n", (clock() - t0) / CLOCKS_PER_SEC); + free_image_mb (ima_mb); + return 0; } Index: src/dd/eiffel/maini.e =================================================================== --- src/dd/eiffel/maini.e (revision 0) +++ src/dd/eiffel/maini.e (revision 0) @@ -0,0 +1,117 @@ +class MAINI + +creation + make + +feature + + offset : INTEGER + + make is + local + ima_sb : IMAGE_SB + ima_mb : IMAGE_MB + val : INTEGER + size, step, nsteps : INTEGER + t0, t : MICROSECOND_TIME + do + if argument_count > 2 then + io.put_string("usage : exec [size = 800] [nsteps = 200]%N") + else + if argument_count > 0 then + size := argument(1).to_integer + else + size := 800; + end + if argument_count > 1 then + nsteps := argument(2).to_integer + else + nsteps := 200 + end + + val := 51 + -- See comment in ../cl/ti.cl + offset := 509 + + print("Randomized / " + + size.to_string + "x" + size.to_string + " / " + + nsteps.to_string + " steps:%N") + + create ima_sb.make(size * size) + t0.update + from + step := 1 + until + step > nsteps + loop + assign_sb(ima_sb, val) + step := step + 1 + end + t.update + print("SB: " + (t0.elapsed_seconds(t)).to_string + "%N") + + create ima_mb.make(size) + t0.update + from + step := 1 + until + step > nsteps + loop + assign_mb(ima_mb, val) + step := step + 1 + end + t.update + print("MB: " + (t0.elapsed_seconds(t)).to_string + "%N") + end + end + + assign_sb(ima : IMAGE_SB; val : INTEGER) is + local + i : INTEGER + the_offset : INTEGER + n : INTEGER + do + the_offset := 0 + n := ima.n + from + i := 0 + until + i >= n + loop + the_offset := the_offset + offset + ima.data.put(val, the_offset \\ n) + i := i + 1 + end + end + + assign_mb(ima : IMAGE_MB; val : INTEGER) is + local + i : INTEGER + j : INTEGER + offset_i : INTEGER + offset_j : INTEGER + n : INTEGER + do + n := ima.n + offset_j := 0 + from + j := 0 + until + j >= ima.n + loop + offset_j := offset_j + offset + offset_i := 0 + from + i := 0 + until + i >= ima.n + loop + offset_i := offset_i + offset + ima.data.put(val, offset_i \\ n, offset_j \\ n) + i := i + 1 + end + j := j + 1 + end + end + +end -- MAINI Index: src/dd/eiffel/image_mb.e =================================================================== --- src/dd/eiffel/image_mb.e (revision 0) +++ src/dd/eiffel/image_mb.e (revision 0) @@ -0,0 +1,16 @@ +class IMAGE_MB + +create make + +feature + + n : INTEGER + data : ARRAY2[INTEGER] + + make(n_ : INTEGER) is + do + n := n_ + create data.make(0, n_, 0, n_) + end + +end -- IMAGE_MB Index: src/dd/eiffel/main.e =================================================================== --- src/dd/eiffel/main.e (revision 42) +++ src/dd/eiffel/main.e (working copy) @@ -8,38 +7,61 @@ make is local - ima : IMAGE1D_INT + ima_sb : IMAGE_SB + ima_mb : IMAGE_MB val : INTEGER size, step, nsteps : INTEGER - t0, t : TIME + t0, t : MICROSECOND_TIME do - size := 1024 * 1024 - if argument_count /= 0 and argument_count /= 1 then - io.put_string("usage : exec [nsteps = 1]%N") + if argument_count > 2 then + io.put_string("usage : exec [size = 800] [nsteps = 200]%N") + else + if argument_count > 0 then + size := argument(1).to_integer else - if argument_count = 0 then - nsteps := 1 - elseif argument_count = 1 then - nsteps := argument(1).to_integer + size := 800; end - create ima.make(size) + if argument_count > 1 then + nsteps := argument(2).to_integer + else + nsteps := 200 + end + val := 51 + + print("Linear / " + + size.to_string + "x" + size.to_string + " / " + + nsteps.to_string + " steps:%N") + + create ima_sb.make(size * size) + t0.update + from + step := 1 + until + step > nsteps + loop + assign_sb(ima_sb, val) + step := step + 1 + end + t.update + print("SB: " + (t0.elapsed_seconds(t)).to_string + "%N") + + create ima_mb.make(size) t0.update from step := 1 until step > nsteps loop - assign(ima, val) + assign_mb(ima_mb, val) step := step + 1 end t.update - print(t0.elapsed_seconds(t)) - print("%N") + print("MB: " + (t0.elapsed_seconds(t)).to_string + "%N") end end - assign(ima : IMAGE1D_INT; val : INTEGER) is + assign_sb(ima : IMAGE_SB; val : INTEGER) is local i : INTEGER do @@ -53,4 +75,26 @@ end end + assign_mb(ima : IMAGE_MB; val : INTEGER) is + local + i : INTEGER + j : INTEGER + do + from + i := 0 + until + i >= ima.n + loop + from + j := 0 + until + j >= ima.n + loop + ima.data.put(val, i, j) + j := j + 1 + end + i := i + 1 + end + end + end -- MAIN Index: src/dd/eiffel/image_sb.e =================================================================== --- src/dd/eiffel/image_sb.e (revision 0) +++ src/dd/eiffel/image_sb.e (revision 0) @@ -0,0 +1,16 @@ +class IMAGE_SB + +create make + +feature + + n : INTEGER + data : ARRAY[INTEGER] + + make(n_ : INTEGER) is + do + n := n_ + create data.make(0, n_) + end + +end -- IMAGE_SB -- Didier Verna, didier(a)lrde.epita.fr, http://www.lrde.epita.fr/~didier EPITA / LRDE, 14-16 rue Voltaire Tel.+33 (1) 44 08 01 85 94276 Le Kremlin-Bicêtre, France Fax.+33 (1) 53 14 59 22 didier(a)xemacs.org

1 0

[nolimips] 212:
by Noe 08 Jan '06

08 Jan '06

I've introduced something that seems a bit nasty to me: class Cpu { Cpu(Cp0 &cp0): cp0_(cp0) {} Cp0 &cp0_; } class Cpu { Cp0(Cpu &cpu): cpu_(cpu) {} Cpu &cpu_; } class VirtualMachine { VirtualMachine(): cpu_(cp0_), cp0_(cpu_) {} Cpu cpu_; Cp0 cp0_; } So Cpu's constructor is called with a not yet build coprocessor :/ This works well because this constructor requires only the address of a Cp0. What do you think? Dangerous? Index: ChangeLog from Benoît Perrot <benoit(a)lrde.epita.fr> Control coprocessor has the system library * src/vm/cp0.hh, src/vm/cp0.hxx: (set_system_library) New. (raise_syscall) Invoke system library if any. * src/vm/cpu.hh, src/vm/cpu.hxx: (set_system_library) Remove. * src/vm/cpu.cc: (syscall) Raise a syscall exception through cp0. * src/vm/virtual_machine.hh, src/vm/virtual_machine.hxx: (get_cp0) New non-const accessor. (set_system_library) Remove. * src/vm-tasks.cc: Access cp0 to set system library. 2006-01-08 Benoît Perrot <benoit(a)lrde.epita.fr> Index: src/vm/cp0.hh --- src/vm/cp0.hh (revision 211) +++ src/vm/cp0.hh (working copy) @@ -21,6 +21,8 @@ #ifndef VM_CP0_HH # define VM_CP0_HH +# include "vm/fwd.hh" + namespace inst { class Register; } namespace vm @@ -94,13 +96,14 @@ /** \name Constructor and destructor \{ */ public: - Cp0(); + Cp0(Cpu &cpu); /** \} */ public: /// Reset the CPU (set registers to zero) void reset(); + void set_system_library(SystemLibrary *l); /** \name Explicit register accessors \{ */ @@ -132,16 +135,22 @@ /// Raise an address error on load exception void raise_addr_store(); + void raise_syscall(); + void set_fatal_exception(); bool fatal_exception() const; /** \} */ protected: + Cpu &cpu_; + bool fatal_exception_; /// Dedicated registers (32 bits) register_type registers[32]; + + SystemLibrary *system_library_; }; } // namespace vm Index: src/vm/virtual_machine.hxx --- src/vm/virtual_machine.hxx (revision 211) +++ src/vm/virtual_machine.hxx (working copy) @@ -33,6 +33,7 @@ mode_(mode), status_(stop), mmu_(cp0_, memory_), + cp0_(cpu_), cpu_(mmu_, cp0_) { } @@ -46,13 +47,6 @@ } // - inline void - VirtualMachine::set_system_library(SystemLibrary *l) - { - cpu_.set_system_library(l); - } - - // inline const std::vector<register_type> & VirtualMachine::get_call_stack() const { @@ -86,6 +80,11 @@ { return cp0_; } + inline Cp0 & + VirtualMachine::get_cp0() + { + return cp0_; + } inline const Cpu & VirtualMachine::get_cpu() const Index: src/vm/cpu.hh --- src/vm/cpu.hh (revision 211) +++ src/vm/cpu.hh (working copy) @@ -128,8 +128,6 @@ Cp0 &get_cp0(); public: - void set_system_library(SystemLibrary *l); - unsigned get_instruction_counter(inst::Inst::format_type format) const; const std::vector<register_type> &get_call_stack() const; @@ -224,8 +222,6 @@ /// Special Program Counter. register_type pc_; - SystemLibrary *system_library_; - /// Unlimited registers. misc::Table<int, register_type> unlimited_; Index: src/vm/cp0.hxx --- src/vm/cp0.hxx (revision 211) +++ src/vm/cp0.hxx (working copy) @@ -20,6 +20,7 @@ # define VM_CP0_HXX # include "vm/cp0.hh" +# include "vm/system_library.hh" # include "inst/register.hh" @@ -30,7 +31,9 @@ // inline - Cp0::Cp0() + Cp0::Cp0(Cpu &cpu): + cpu_(cpu), + system_library_(0) { reset(); } @@ -45,6 +48,12 @@ fatal_exception_ = false; } + inline void + Cp0::set_system_library(SystemLibrary *l) + { + system_library_ = l; + } + // inline void Cp0::set_count(Cp0::register_type r) @@ -99,6 +108,13 @@ fatal_exception_ = true; } + inline void + Cp0::raise_syscall() + { + precondition(system_library_); + system_library_->invoke(cpu_); + } + // inline void Cp0::set_fatal_exception() Index: src/vm/cpu.hxx --- src/vm/cpu.hxx (revision 211) +++ src/vm/cpu.hxx (working copy) @@ -141,12 +141,6 @@ return cp0_; } - inline void - Cpu::set_system_library(SystemLibrary *l) - { - system_library_ = l; - } - // inline void Cpu::call() Index: src/vm/virtual_machine.hh --- src/vm/virtual_machine.hh (revision 211) +++ src/vm/virtual_machine.hh (working copy) @@ -69,8 +69,6 @@ /// Load a program into memory. void load_program(const inst::Program &program); - void set_system_library(SystemLibrary *l); - public: /// Execute a program. void execute(); @@ -98,6 +96,7 @@ status_type get_status() const; const Cp0 &get_cp0() const; + Cp0 &get_cp0(); const Cpu &get_cpu() const; Cpu &get_cpu(); Index: src/vm/cpu.cc --- src/vm/cpu.cc (revision 211) +++ src/vm/cpu.cc (working copy) @@ -20,7 +20,6 @@ #include "vm/cpu.hh" #include "vm/cp0.hh" -#include "vm/system_library.hh" #include "inst/all.hh" #include "inst/int_exp.hh" @@ -33,7 +32,6 @@ // -------------------------------------------------------------------------- Cpu::Cpu(Mmu &mmu, Cp0 &cp0): mmu_(mmu), cp0_(cp0), - system_library_(0), check_callee_save_p_(false), trace_p_(false), bubble_(new inst::Sll(inst::Register(inst::Register::general, Cpu::zero), @@ -684,8 +682,7 @@ void Cpu::visit(const inst::Syscall&) { - precondition(system_library_); - system_library_->invoke(*this); + cp0_.raise_syscall(); } } // namespace vm Index: src/vm-tasks.cc --- src/vm-tasks.cc (revision 211) +++ src/vm-tasks.cc (working copy) @@ -72,7 +72,7 @@ vm::VirtualMachine vm; vm.get_cpu().set_check_callee_save(check_callee_save_p); vm.get_cpu().set_trace(trace_exec_p); - vm.set_system_library(system_library); + vm.get_cp0().set_system_library(system_library); vm.load_program(* parse::tasks::program); if (exit_status != exit_success) exit(exit_status);

1 0

[nolimips] 211: Do not call exit_set inside control coprocessor
by Noe 08 Jan '06

08 Jan '06

Index: ChangeLog from Benoît Perrot <benoit(a)lrde.epita.fr> Do not call exit_set inside control coprocessor * src/vm/cp0.hh, src/vm/cp0.hxx: (get_register) New. (raise_overflow, raise_addr_load, raise_addr_store): Activate fatal_exception_, remove call to exit_set. * src/vm/virtual_machine.cc: (execute) Use exit_set to report internal exception. 2006-01-08 Benoît Perrot <benoit(a)lrde.epita.fr> Index: src/vm/cp0.hh --- src/vm/cp0.hh (revision 210) +++ src/vm/cp0.hh (working copy) @@ -116,6 +116,8 @@ void set_register(const inst::Register &reg, register_type r); /// Return the register identified by \a reg. register_type get_register(const inst::Register &reg) const; + + register_type get_register(kind_type k) const; /** \} */ Index: src/vm/cp0.hxx --- src/vm/cp0.hxx (revision 210) +++ src/vm/cp0.hxx (working copy) @@ -69,6 +69,11 @@ precondition(reg.get_kind() == inst::Register::generic); return registers[reg.get_index()]; } + inline Cp0::register_type + Cp0::get_register(kind_type k) const + { + return registers[k]; + } // inline void @@ -76,7 +81,7 @@ { registers[cause] = overflow; std::cerr << "Runtime Exception: Overflow" << std::endl; - exit_set(exit_runtime); + fatal_exception_ = true; } inline void @@ -85,7 +90,6 @@ registers[cause] = addr_load; std::cerr << "Runtime Exception: Address error on load" << std::endl; fatal_exception_ = true; - exit_set(exit_runtime); } inline void Cp0::raise_addr_store() @@ -93,7 +97,6 @@ registers[cause] = addr_store; std::cerr << "Runtime Exception: Address error on store" << std::endl; fatal_exception_ = true; - exit_set(exit_runtime); } // Index: src/vm/virtual_machine.cc --- src/vm/virtual_machine.cc (revision 210) +++ src/vm/virtual_machine.cc (working copy) @@ -66,6 +66,10 @@ cpu_.step(); cp0_.set_count(cp0_.get_count() + 1); } + + // FIXME: this is not the good test, but for the moment it suffices + if (cp0_.get_register(Cp0::cause) != Cp0::interrupt) + exit_set(exit_runtime); } void

1 0

[nolimips] 210: Remove dirty access to libparse internal
by Noe 08 Jan '06

08 Jan '06

Index: ChangeLog from Benoît Perrot <benoit(a)lrde.epita.fr> Remove dirty access to libparse internal * src/inst/program_solver.gen.py, src/inst/program_solver.hxx: Replace dirty access to libparse internal by an internal flag. * src/inst-tasks.cc: Use it. 2006-01-08 Benoît Perrot <benoit(a)lrde.epita.fr> Index: src/inst-tasks.cc --- src/inst-tasks.cc (revision 209) +++ src/inst-tasks.cc (working copy) @@ -18,6 +18,8 @@ // #include "common.hh" +#include "parse/libparse.hh" + #include "inst/program_solver.hh" #include "parse-tasks.hh" @@ -43,6 +45,7 @@ program_solver.set_max_callee_save(max_callee_save); program_solver.set_max_caller_save(max_caller_save); program_solver.set_max_args(max_args); + program_solver.enable_unlimited_regs(parse::unlimited_regs_p); program_solver.solve(* parse::tasks::program); if (exit_status != exit_success) exit (exit_status); Index: src/inst/program_solver.gen.py --- src/inst/program_solver.gen.py (revision 209) +++ src/inst/program_solver.gen.py (working copy) @@ -65,6 +65,8 @@ void set_max_caller_save(int max_caller_save); void set_max_args(int max_args); + void enable_unlimited_regs(bool flag = true); + public: void solve(Program &program); @@ -94,6 +96,8 @@ int max_callee_save_; int max_caller_save_; int max_args_; + + bool unlimited_regs_enabled_; }; } // namespace inst @@ -122,9 +126,6 @@ #include \"vm/cpu.hh\" -// FIXME: dirty access unlimited registers flag -# include \"parse/libparse.hh\" - namespace inst { @@ -212,7 +213,7 @@ } break; case Register::unlimited: - if (!parse::unlimited_regs_p) + if (!unlimited_regs_enabled_) { std::cerr << \"Unlimited registers prohibited.\" << std::endl; exit_set(exit_solve); Index: src/inst/program_solver.hxx --- src/inst/program_solver.hxx (revision 209) +++ src/inst/program_solver.hxx (working copy) @@ -30,7 +30,8 @@ inline ProgramSolver::ProgramSolver(): program_(0), - max_callee_save_(8), max_caller_save_(10), max_args_(4) + max_callee_save_(8), max_caller_save_(10), max_args_(4), + unlimited_regs_enabled_(false) { } @@ -51,6 +52,12 @@ max_args_ = max_args; } + inline void + ProgramSolver::enable_unlimited_regs(bool flag) + { + unlimited_regs_enabled_ = flag; + } + // inline void ProgramSolver::solve(Program &program)

1 0

[nolimips] 209: Move inline implementations from .hh files to .hxx
by Noe 08 Jan '06

08 Jan '06

How boring / time consuming... This should have been done a long time ago. Index: trunk/ChangeLog from Benoît Perrot <benoit(a)lrde.epita.fr> Move inline implementations from .hh files to .hxx * src/inst/register.hh, * src/inst/label.hh, * src/inst/text_label.hh, * src/inst/exp.hh, * src/inst/int_exp.hh, * src/inst/label_exp.hh, * src/inst/op_exp.hh, * src/inst/inst.hh, * src/inst/section.hh, * src/inst/data_section.hh, * src/inst/text_section.hh, * src/inst/program.hh, * src/inst/program_builder.hh.gen.py, * src/inst/program_solver.gen.py, * src/vm/cp0.hh, * src/vm/cpu.hh, * src/vm/mmu.hh, * src/vm/memory.hh, * src/vm/segment.hh, * src/vm/system_library.hh, * src/vm/spim_system_library.hh, * src/vm/nolimips_system_library.hh, * src/vm/virtual_machine.hh, * src/shell/cmd.hh, * src/shell/shell.hh, * src/task/task.hh, * src/task/task_register.hh: Split into... * src/inst/register.hxx, * src/inst/label.hxx, src/inst/label.cc, * src/inst/text_label.hxx, src/inst/text_label.cc, * src/inst/exp.hxx, src/inst/exp.cc, * src/inst/int_exp.hxx, src/inst/int_exp.cc, * src/inst/label_exp.hxx, src/inst/label_exp.cc, * src/inst/op_exp.hxx, src/inst/op_exp.cc, * src/inst/inst.hxx, src/inst/inst.cc, * src/inst/section.hxx, src/inst/section.cc, * src/inst/data_section.hxx, src/inst/data_section.cc, * src/inst/text_section.hxx, src/inst/text_section.cc, * src/inst/program.hxx, * src/inst/program_builder.hxx, * src/inst/program_solver.hxx, * src/vm/cp0.hxx, * src/vm/cpu.hxx, src/vm/cpu.cc, * src/vm/mmu.hxx, * src/vm/memory.hxx, * src/vm/segment.hxx, * src/vm/system_library.hxx, src/vm/system_library.cc, * src/vm/spim_system_library.hxx, src/vm/spim_system_library.cc, * src/vm/nolimips_system_library.hxx, src/vm/nolimips_system_library.cc, * src/vm/virtual_machine.hxx, src/vm/virtual_machine.cc, * src/shell/cmd.hxx, * src/shell/shell.hxx, src/shell/shell.cc, * src/task/task.hxx, src/task/task.cc, * src/task/task_register.hxx, src/task/task_register.cc: ... These files, respectively. * src/inst/Makefile.am, * src/shell/Makefile.am, * src/task/Makefile.am, * src/vm/Makefile.am: Update accordingly. * src/inst/exp-visitor.hh: Use fwd.hh * src/task-tasks.cc, src/nolimips-tasks.cc: Include task_register.hh * src/task/boolean_task.hh, * src/task/function_task.hh, * src/task/int_task.hh, * src/task/string_task.hh: Homogeneize coding style.

1 0

[nolimips] 208: Print a generated-file warning
by Noe 07 Jan '06

07 Jan '06

Index: ChangeLog from Benoît Perrot <benoit(a)lrde.epita.fr> Print a generated-file warning at the beginning of generated files. Suggested by Roland Levillain. * dev/nolimips.py (generated_by_hand): Add warning string. * src/parse/asm-parse.yy.gen.py, * src/parse/asm-scan.ll.gen.py, * src/inst/program_solver.gen.py, * src/inst/nodes.gen.py, * src/inst/program_builder.hh.gen.py, Print warning right after license. * src/inst/nodes.mk.gen.py: Remove a useless import. 2006-01-07 Benoît Perrot <benoit(a)lrde.epita.fr> Index: src/parse/asm-parse.yy.gen.py --- src/parse/asm-parse.yy.gen.py (revision 207) +++ src/parse/asm-parse.yy.gen.py (working copy) @@ -1,7 +1,7 @@ #!/usr/bin/env python ## ## This file is part of Nolimips, a MIPS simulator with unlimited registers -## Copyright (C) 2003, 2004 Benoit Perrot <benoit(a)lrde.epita.fr> +## Copyright (C) 2003, 2004, 2006 Benoit Perrot <benoit(a)lrde.epita.fr> ## ## Nolimips is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by @@ -22,7 +22,7 @@ import string, re import nolimips -from nolimips import license, depth, define_id +from nolimips import depth, define_id #### Nolimips' Bison assembly parser generator ------------- @@ -38,7 +38,8 @@ ## Prologue -------------------------- print "%{ // -*- C++ -*-" -print license +print nolimips.license +print nolimips.generated_by_hand print """ #include <string> Index: src/parse/asm-scan.ll.gen.py --- src/parse/asm-scan.ll.gen.py (revision 207) +++ src/parse/asm-scan.ll.gen.py (working copy) @@ -1,7 +1,7 @@ #!/usr/bin/env python ## ## This file is part of Nolimips, a MIPS simulator with unlimited registers -## Copyright (C) 2003, 2004 Benoit Perrot <benoit(a)lrde.epita.fr> +## Copyright (C) 2003, 2004, 2006 Benoit Perrot <benoit(a)lrde.epita.fr> ## ## Nolimips is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by @@ -22,7 +22,7 @@ import string, re import nolimips -from nolimips import license, define_id +from nolimips import define_id #### Nolimips' Flex scanner generator -------------------------- @@ -38,7 +38,8 @@ ## Prologue ---------------------------- print "%{ /* -*- C++ -*- */" -print license +print nolimips.license +print nolimips.generated_by_hand print """ #include <string> #include <sstream> Index: src/inst/program_solver.gen.py --- src/inst/program_solver.gen.py (revision 207) +++ src/inst/program_solver.gen.py (working copy) @@ -22,7 +22,7 @@ import string, re import nolimips -from nolimips import license, depth, class_id +from nolimips import depth, class_id #### Nolimips' program solver generator -------------------- @@ -38,7 +38,8 @@ ## Generate interface sys.stdout = file("program_solver.hh.tmp", "w") -print license +print nolimips.license +print nolimips.generated_by_hand print """#ifndef INST_PROGRAM_SOLVER_HH # define INST_PROGRAM_SOLVER_HH @@ -145,7 +146,8 @@ ## Generate implementation sys.stdout = file("program_solver.cc.tmp", "w") -print license +print nolimips.license +print nolimips.generated_by_hand print """#include \"inst/program_solver.hh\" #include \"inst/int_exp.hh\" #include \"inst/label_exp.hh\" Index: src/inst/nodes.gen.py --- src/inst/nodes.gen.py (revision 207) +++ src/inst/nodes.gen.py (working copy) @@ -43,7 +43,7 @@ class_id = nolimips.class_id(inst.opcode) define_id = nolimips.define_id(inst.opcode) file_id = nolimips.file_id(inst.opcode) - banner = nolimips.license + "\n// Generated, do not edit by hand." + banner = nolimips.license + "\n" + nolimips.generated_by_hand format = inst.format ## Open header, inline and implementation files @@ -262,6 +262,7 @@ ## Generate all-includer sys.stdout = file("all.hh.tmp", "w") print nolimips.license +print nolimips.generated_by_hand print "#ifndef INST_ALL_HH" print "# define INST_ALL_HH" for inst in instructions: @@ -276,6 +277,7 @@ ## Generate all-declarator sys.stdout = file("fwd.hh.tmp", "w") print nolimips.license +print nolimips.generated_by_hand print """ #ifndef INST_FWD_HH # define INST_FWD_HH @@ -326,6 +328,7 @@ ## Generate visitor sys.stdout = file("visitor.hh.tmp", "w") print nolimips.license +print nolimips.generated_by_hand print """#ifndef INST_VISITOR_HH # define INST_VISITOR_HH Index: src/inst/program_builder.hh.gen.py --- src/inst/program_builder.hh.gen.py (revision 207) +++ src/inst/program_builder.hh.gen.py (working copy) @@ -1,7 +1,7 @@ #!/usr/bin/env python ## ## This file is part of Nolimips, a MIPS simulator with unlimited registers -## Copyright (C) 2003, 2004 Benoit Perrot <benoit(a)lrde.epita.fr> +## Copyright (C) 2003, 2004, 2006 Benoit Perrot <benoit(a)lrde.epita.fr> ## ## Nolimips is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by @@ -22,7 +22,7 @@ import string, re import nolimips -from nolimips import license, depth, class_id +from nolimips import depth, class_id #### Nolimips' program builder generator ------------------- @@ -36,7 +36,8 @@ sys.stdout = file("program_builder.hh.tmp", "w") -print license +print nolimips.license +print nolimips.generated_by_hand print """#ifndef INST_PROGRAM_BUILDER_HH # define INST_PROGRAM_BUILDER_HH Index: src/inst/nodes.mk.gen.py --- src/inst/nodes.mk.gen.py (revision 207) +++ src/inst/nodes.mk.gen.py (working copy) @@ -22,7 +22,7 @@ import string, re import nolimips -from nolimips import license, depth +from nolimips import depth #### Nolimips' inst/Makefile.am generator ------------------ Index: dev/nolimips.py --- dev/nolimips.py (revision 207) +++ dev/nolimips.py (working copy) @@ -1,7 +1,7 @@ #!/usr/bin/env python ## ## This file is part of Nolimips, a MIPS simulator with unlimited registers -## Copyright (C) 2003, 2004, 2005 Benoit Perrot <benoit(a)lrde.epita.fr> +## Copyright (C) 2003, 2004, 2005, 2006 Benoit Perrot <benoit(a)lrde.epita.fr> ## ## Nolimips is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by @@ -26,7 +26,7 @@ license = """// // This file is part of Nolimips, a MIPS simulator with unlimited registers -// Copyright (C) 2004, 2005 Benoit Perrot <benoit(a)lrde.epita.fr> +// Copyright (C) 2004, 2005, 2006 Benoit Perrot <benoit(a)lrde.epita.fr> // // Nolimips is free software; you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by @@ -41,7 +41,13 @@ // You should have received a copy of the GNU General Public License // along with this program; if not, write to the Free Software // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -//""" +// +""" + +generated_by_hand = """// +// WARNING: Generated file, do not edit by hand! +// +""" ## --------------------------------------------------------------------------- def depth(root):

1 0