Projects

projects@lrde.epita.fr

1049 discussions

[genericity-support-comparison] Update README

by Didier Verna

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

19 years

[genericity-support-comparison] Add Common Lisp dedicated version

by Didier Verna

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

19 years

[COMMIT] [genericity-support-comparison] Update dedicated versions

by Didier Verna

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

19 years

[nolimips] 212:

by Noe

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);

19 years

[nolimips] 211: Do not call exit_set inside control coprocessor

by Noe

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

19 years

[nolimips] 210: Remove dirty access to libparse internal

by Noe

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)

19 years

[nolimips] 209: Move inline implementations from .hh files to .hxx

by Noe

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.

19 years

[nolimips] 208: Print a generated-file warning

by Noe

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):

19 years

[nolimips] 207: Add forward declarations files

by Noe

It seems that there is a flaw in the handling of the file nodes.mk, which is not regenerated when nodes.mk.gen.py is touched. I will investigate this... later :P Index: ChangeLog from Benoît Perrot <benoit(a)lrde.epita.fr> Add forward declarations files * src/inst/nodes.gen.py: Generate forward declarations in an fwd.hh file instead of decl.hh * src/inst/nodes.mk.gen.py: Update accordingly. * src/parse/fwd.hh: New. * src/parse/Makefile.am: Distribute. * src/vm/fwd.hh: New. * src/vm/Makefile.am: Distribute. Index: src/vm/Makefile.am --- src/vm/Makefile.am (revision 206) +++ src/vm/Makefile.am (working copy) @@ -2,6 +2,7 @@ libvm_la_CPPFLAGS = -I $(top_srcdir)/lib -I $(top_srcdir)/src -I $(top_builddir)/src libvm_la_SOURCES = \ + fwd.hh \ mmu.hh \ cp0.hh \ cpu.hh cpu.cc \ Index: src/vm/fwd.hh --- src/vm/fwd.hh (revision 0) +++ src/vm/fwd.hh (revision 207) @@ -0,0 +1,42 @@ +// +// This file is part of Nolimips, a MIPS simulator with unlimited registers +// Copyright (C) 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 +// the Free Software Foundation; either version 2 of the License, or +// (at your option) any later version. +// +// Nolimips is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// 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 +// +#ifndef VM_FWD_HH +# define VM_FWD_HH + +namespace inst { class Program; } + +namespace vm +{ + + class Cp0; + class Cpu; + class Mmu; + + class Memory; + class Segment; + + class SystemLibrary; + class NolimipsSystemLibrary; + class SpimSystemLibrary; + + class VirtualMachine; + +} // namespace vm + +#endif // !VM_FWD_HH Index: src/parse/Makefile.am --- src/parse/Makefile.am (revision 206) +++ src/parse/Makefile.am (working copy) @@ -58,6 +58,7 @@ libparse_la_CPPFLAGS = -I $(top_srcdir)/src -I $(top_builddir)/src libparse_la_SOURCES = \ + fwd.hh \ asm-parse.cc asm-parse.yy.stamp \ $(FROM_ASM_PARSE_YY) \ asm-scan.ll asm-scan.hh asm-scan.ll.stamp \ Index: src/parse/fwd.hh --- src/parse/fwd.hh (revision 0) +++ src/parse/fwd.hh (revision 207) @@ -0,0 +1,30 @@ +// +// This file is part of Nolimips, a MIPS simulator with unlimited registers +// Copyright (C) 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 +// the Free Software Foundation; either version 2 of the License, or +// (at your option) any later version. +// +// Nolimips is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// 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 +// + +#ifndef PARSE_FWD_HH +# define PARSE_FWD_HH + +namespace yy +{ + class position; + class location; + class parser; +} + +#endif // !PARSE_FWD_HH Index: src/inst/nodes.gen.py --- src/inst/nodes.gen.py (revision 206) +++ src/inst/nodes.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 @@ -274,26 +274,54 @@ os.remove("all.hh.tmp") ## Generate all-declarator -sys.stdout = file("decl.hh.tmp", "w") +sys.stdout = file("fwd.hh.tmp", "w") print nolimips.license -print "#ifndef INST_DECL_HH" -print "# define INST_DECL_HH" print """ +#ifndef INST_FWD_HH +# define INST_FWD_HH + +# include \"misc/select_const.hh\" + namespace inst { + + class Register; + class Label; + class TextLabel; + + class Exp; + class IntExp; + class LabelExp; + class OpExp; + + template <typename ConstKind> + class GenExpVisitor; + typedef GenExpVisitor<const_kind> ConstExpVisitor; + typedef GenExpVisitor<non_const_kind> ExpVisitor; + + class Inst; """ for inst in instructions: if inst.level == "native": print " class " + nolimips.class_id(inst.opcode) + ";" print """ + + class Section; + class TextSection; + class DataSection; + + class Program; + class ProgramBuilder; + class ProgramSolver; + } // namespace inst -#endif // !INST_DECL_HH +#endif // !INST_FWD_HH """ sys.stdout.close() sys.stdout = sys.__stdout__ -nolimips.lazy_overwrite(srcdir + os.sep + "decl.hh", "decl.hh.tmp") -os.remove("decl.hh.tmp") +nolimips.lazy_overwrite(srcdir + os.sep + "fwd.hh", "fwd.hh.tmp") +os.remove("fwd.hh.tmp") ## Generate visitor sys.stdout = file("visitor.hh.tmp", "w") @@ -303,7 +331,7 @@ # include \"misc/select_const.hh\" -# include \"inst/decl.hh\" +# include \"inst/fwd.hh\" namespace inst { Index: src/inst/nodes.mk.gen.py --- src/inst/nodes.mk.gen.py (revision 206) +++ src/inst/nodes.mk.gen.py (working copy) @@ -36,6 +36,6 @@ for ext in ["hh", "hxx", "cc"]: line = line + instructions[i].opcode + "." + ext + " " print line + "\t\t\\" -print """ decl.hh \\ +print """ fwd.hh \\ all.hh \\ visitor.hh"""

19 years

[CVS bison] extexi & calc++-parser.yy

by Noe

Bon, on se rassure, ce n'est rien de grave. Je viens de sortir bison de son CVS. Curieux, j'ai ouvert examples/calc++/calc++-parser.yy dans emacs, et j'ai trouve qu'il manquait quelque chose. Genre la couleur :) En voici les deux premieres lignes : #line 7287 "../../doc/bison.texinfo" %skeleton "lalr1.cc" /* -*- C++ -*- */ Manque de bol, /* -*- C++ -*- */ n'a pas d'effet si la directive n'est pas sur la premiere ligne non vide. J'aurais bien propose de patcher extexi, mais je dois avouer etre un peu sec. Une nouvelle directive ? Un argument ? No se. M'enfin bon, je repete, ce n'est pas grave. C'est juste histoire de dire :) -- Noe

19 years

Jump to page:

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

Projects