login  home  contents  what's new  discussion  bug reports     help  links  subscribe  changes  refresh  edit

Adding new functions to PrimitiveArray? in an attempt to improve performance.

new(n,x:NNI->S)
create new array of size n with values from x(i),i=0..n-1
fill!(n,x:NNI->S)
set the elements of array with values from x(i),i=0..n-1

This is the code for Axiom's PrimitiveArray? domain with two small changes for options to call new and fill! with an initialization function rather than just a constant.

spad
)abbrev domain XPRIMARR XPrimitiveArray
NNI ==> NonNegativeInteger
-- This provides a fast array type with no bound checking on elt's.
-- Minimum index is 0 in this type, cannot be changed
XPrimitiveArray(S:Type): OneDimensionalArrayAggregate S with
     new:(NNI,NNI->S)->%
     fill!:(%,NNI->S)->%
  == add
   Qmax ==> QVMAXINDEX$Lisp
   Qsize ==> QVSIZE$Lisp
   Qelt ==> QAREF1$Lisp
   Qsetelt ==> QSETAREF1$Lisp
   Qnew ==> MAKE_-ARRAY$Lisp
   Qnew1 ==> MAKEARR1$Lisp
#x == Qsize x minIndex x == 0 empty() == Qnew(0$Lisp) new(n:NNI, x:S):% == Qnew1(n, x) new(n:NNI, x:NNI->S):% == fill!(Qnew n, x) qelt(x, i) == Qelt(x, i) elt(x:%, i:Integer) == Qelt(x, i) qsetelt!(x, i, s) == Qsetelt(x, i, s) setelt(x:%, i:Integer, s:S) == Qsetelt(x, i, s) fill!(x:%, s:S):% == (for i in 0..Qmax x repeat Qsetelt(x, i, s); x) fill!(x:%, s:NNI->S):% == (for i in 0..Qmax x repeat Qsetelt(x, i, s(i)); x)
spad
   Compiling FriCAS source code from file 
      /var/lib/zope2.10/instance/axiom-wiki/var/LatexWiki/7411497222316612988-25px001.spad
      using old system compiler.
   XPRIMARR abbreviates domain XPrimitiveArray 
------------------------------------------------------------------------
   initializing NRLIB XPRIMARR for XPrimitiveArray 
   compiling into NRLIB XPRIMARR 
   processing macro definition Qmax ==> elt(Lisp,QVMAXINDEX) 
   processing macro definition Qsize ==> elt(Lisp,QVSIZE) 
   processing macro definition Qelt ==> elt(Lisp,QAREF1) 
   processing macro definition Qsetelt ==> elt(Lisp,QSETAREF1) 
   processing macro definition Qnew ==> elt(Lisp,MAKE-ARRAY) 
   processing macro definition Qnew1 ==> elt(Lisp,MAKEARR1) 
   compiling exported # : $ -> NonNegativeInteger
      XPRIMARR;#;$Nni;1 is replaced by QVSIZE 
Time: 0.01 SEC.
compiling exported minIndex : $ -> Integer XPRIMARR;minIndex;$I;2 is replaced by 0 Time: 0 SEC.
compiling exported empty : () -> $ XPRIMARR;empty;$;3 is replaced by MAKE-ARRAY0 Time: 0 SEC.
compiling exported new : (NonNegativeInteger,S) -> $ XPRIMARR;new;NniS$;4 is replaced by MAKEARR1 Time: 0 SEC.
compiling exported new : (NonNegativeInteger,NonNegativeInteger -> S) -> $ Time: 0 SEC.
compiling exported qelt : ($,Integer) -> S XPRIMARR;qelt;$IS;6 is replaced by QAREF1 Time: 0 SEC.
compiling exported elt : ($,Integer) -> S XPRIMARR;elt;$IS;7 is replaced by QAREF1 Time: 0 SEC.
compiling exported qsetelt! : ($,Integer,S) -> S XPRIMARR;qsetelt!;$I2S;8 is replaced by QSETAREF1 Time: 0 SEC.
compiling exported setelt : ($,Integer,S) -> S XPRIMARR;setelt;$I2S;9 is replaced by QSETAREF1 Time: 0 SEC.
compiling exported fill! : ($,S) -> $ Time: 0.01 SEC.
compiling exported fill! : ($,NonNegativeInteger -> S) -> $ Time: 0 SEC.
****** Domain: S already in scope augmenting S: (BasicType) ****** Domain: S already in scope augmenting S: (SetCategory) ****** Domain: S already in scope augmenting S: (OrderedSet) ****** Domain: S already in scope augmenting S: (Evalable S) ****** Domain: S already in scope augmenting S: (SetCategory) ****** Domain: S already in scope augmenting S: (BasicType) ****** Domain: S already in scope augmenting S: (CoercibleTo (OutputForm)) ****** Domain: S already in scope augmenting S: (ConvertibleTo (InputForm)) ****** Domain: S already in scope augmenting S: (OrderedSet) ****** Domain: S already in scope augmenting S: (SetCategory) (time taken in buildFunctor: 10)
;;; *** |XPrimitiveArray| REDEFINED
;;; *** |XPrimitiveArray| REDEFINED Time: 0.03 SEC.
Cumulative Statistics for Constructor XPrimitiveArray Time: 0.05 seconds
finalizing NRLIB XPRIMARR Processing XPrimitiveArray for Browser database: --->-->XPrimitiveArray(constructor): Not documented!!!! --->-->XPrimitiveArray((new (% (NonNegativeInteger) (Mapping S (NonNegativeInteger))))): Not documented!!!! --->-->XPrimitiveArray((fill! (% % (Mapping S (NonNegativeInteger))))): Not documented!!!! --->-->XPrimitiveArray(): Missing Description ; compiling file "/var/aw/var/LatexWiki/XPRIMARR.NRLIB/XPRIMARR.lsp" (written 26 JUL 2013 05:04:26 PM):
; /var/aw/var/LatexWiki/XPRIMARR.NRLIB/XPRIMARR.fasl written ; compilation finished in 0:00:00.053 ------------------------------------------------------------------------ XPrimitiveArray is now explicitly exposed in frame initial XPrimitiveArray will be automatically loaded when needed from /var/aw/var/LatexWiki/XPRIMARR.NRLIB/XPRIMARR

How long does this take?

First, it seems to make a big difference whether the initialization is done by an anonymous function or by a named function since the latter can be compiled and called with very little overhead. In other words using:

  init1(x:Integer):Integer == random(100)-random(100)

is much better than this:

fricas
)time on
l0:PRIMARR(INT):=new(100000,0); map!(x+->random(100)-random(100),l0);
Type: PrimitiveArray?(Integer)
fricas
Time: 0.01 (EV) + 0.01 (OT) = 0.02 sec

Old way using a compiled initialization function with the map! function:

fricas
init1(x:Integer):Integer == random(100)-random(100)
Function declaration init1 : Integer -> Integer has been added to workspace.
Type: Void
fricas
Time: 0 sec
l1:PRIMARR(INT):=new(100000,0); map!(init1,l1);
fricas
Compiling function init1 with type Integer -> Integer
Type: PrimitiveArray?(Integer)
fricas
Time: 0.01 (EV) = 0.01 sec

New way with the call to the initialization function builtin to the new function:

fricas
init2(x:NNI):Integer == random(100)-random(100)
Function declaration init2 : NonNegativeInteger -> Integer has been added to workspace.
Type: Void
fricas
Time: 0 sec
l2:XPRIMARR(INT):=new(100000,init2);
fricas
Compiling function init2 with type NonNegativeInteger -> Integer
Type: XPrimitiveArray?(Integer)
fricas
Time: 0.01 (EV) = 0.01 sec

Show the first few entries

fricas
for i in 0..10 repeat output [l0.i,l1.i,l2.i]
[48,- 11,- 13] [90,44,27] [39,- 31,20] [- 56,4,- 55] [- 31,- 76,- 40] [- 69,- 87,16] [- 73,- 9,17] [16,- 21,24] [- 4,- 88,3] [- 40,- 10,33] [- 65,19,8]
Type: Void
fricas
Time: 0.02 (OT) = 0.02 sec




  Subject:   Be Bold !!
  ( 13 subscribers )  
Please rate this page: