BLAST bug about blast-documentation

[nijnstein]

having a million executions allows ssmd to shine

[nijnstein]

Hi, Thanks for taking the time to log this issue:

• The first version is a little rough, we appologise for that. A new version 1.0.2 is uploaded to unity and will be released into the asset store hopefully monday.
• 1.0.0 also has a bug in release builds but that is not your problem here.

That said, the sample should work out of the box. Its as if blast is initialized without the scriptapi added to it.

Is there is no change in code?

[nijnstein]

Could you show me the output of a log message you should have in your log called "BLAST: Known script functions:"

It should look like:

BLAST: known script functions:

Index FID FunctionName Operation Extended Op

 3      3   yield                            yield        nop         
 4      4   pop                              pop          nop         
 5      5   peek                             peek         nop         
 6      6   seed                             seed         nop         
 7      7   push                             push         nop         
 8      8   pushf                            pushf        nop         
 9      9   pushc                            pushc        nop         
10     10   pushv                            pushv        nop         
11     11   debug                            ex_op        debug       
12     12   debugstack                       ex_op        debugstack  
13     13   validate                         ex_op        validate    
32     32   return                           ret          nop         
33     33   abs                              abs          nop         
34     34   min                              min          nop         
35     35   max                              max          nop         
36     36   mina                             mina         nop         
37     37   maxa                             maxa         nop         
38     38   any                              any          nop         
39     39   all                              all          nop         
40     40   adda                             adda         nop         
41     41   suba                             suba         nop         
42     42   diva                             diva         nop         
43     43   mula                             mula         nop         
44     44   fma                              fma          nop         
45     45   fmod                             ex_op        fmod        
46     46   trunc                            trunc        nop         
47     47   csum                             csum         nop         
48     48   select                           select       nop         
49     49   random                           random       nop         
50     50   idx                              index_x      nop         
51     51   idy                              index_y      nop         
52     52   idz                              index_z      nop         
53     53   idw                              index_w      nop         
54     54   expand2                          expand_v2    nop         
55     55   expand3                          expand_v3    nop         
56     56   expand4                          expand_v4    nop         
57     57   sin                              ex_op        sin         
58     58   cos                              ex_op        cos         
59     59   tan                              ex_op        tan         
60     60   atan                             ex_op        atan        
61     61   atan2                            ex_op        atan2       
62     62   cosh                             ex_op        cosh        
63     63   sinh                             ex_op        sinh        
64     64   degrees                          ex_op        degrees     
65     65   rad                              ex_op        radians     
66     66   sqrt                             ex_op        sqrt        
67     67   rsqrt                            ex_op        rsqrt       
68     68   pow                              ex_op        pow         
69     69   normalize                        ex_op        normalize   
70     70   saturate                         ex_op        saturate    
71     71   clamp                            ex_op        clamp       
72     72   log2                             ex_op        log2        
73     73   log10                            ex_op        log10       
74     74   log                              ex_op        logn        
75     75   exp                              ex_op        exp         
76     76   exp10                            ex_op        exp10       
77     77   cross                            ex_op        cross       
78     78   dot                              ex_op        dot         
79     79   ceil                             ex_op        ceil        
80     80   floor                            ex_op        floor       
81     81   frac                             ex_op        frac        
82     82   lerp                             ex_op        lerp        
83     83   slerp                            ex_op        slerp       
84     84   nlerp                            ex_op        nlerp       
85     85   unlerp                           ex_op        unlerp      
86     86   remap                            ex_op        remap       
87     87   ceillog2                         ex_op        ceillog2    
88     88   floorlog2                        ex_op        floorlog2   
89     89   ceilpow2                         ex_op        ceilpow2    
90     90   set_bits                         set_bits     nop         
91     91   set_bit                          set_bit      nop         
92     92   get_bits                         get_bits     nop         
93     93   get_bit                          get_bit      nop         
94     94   count_bits                       ex_op        count_bits  
95     95   reverse_bits                     ex_op        reverse_bits
96     96   shl                              ex_op        shl         
97     97   shr                              ex_op        shr         
98     98   rol                              ex_op        rol         
99     99   ror                              ex_op        ror   

Select should be present in this list at [48], if not something is going wrong during initialization

[ruribev]

Thanks for the quick reply! Don't worry, I can wait for the update.

I want to take the opportunity to say that the concept of BLAST seems incredible to me and it is something that I had thought of doing in a much simpler way.

My main concerns right now are the following:

• How efficient it is on large datasets like 1 million floats.
• And for my particular case I have datasets with integers and doubles and I was wondering if there is a way to deal with these cases with BLAST in a simple way?

I would appreciate it if you could give me some head start on how to deal with these cases so that when I start to see more of BLAST in detail, I can understand better how to do this cases.

Thanks in advance for the support and I see with great emotion what can be done with BLAST

[nijnstein]

processing millions of floats has 1 problem, there is no way to address large arrays (yet), usually it should be operated the other way around: run a simple script millions of times on that array while mapping the datasegment directly to that array, then ssmd can also benifit maximally.

• If there is no other way then currently the only option is to use external functions to access a large array through some get(index) function, it would lose some performance.

In future releases however:

• A pointertype will be introduced that allows indexing a pointer as an array of one of the supported datatypes.
• 32 bit integers will be supported as if they were floats in vectorsize 1-4
• 64 bit doubles will be handled only as vectorsize 1 (metadata size limits, need to choose)
• 16 bit floats will be possible in vectorsizes 2 and 4

The next release includes a CDATA section that could be used as fixed arrays but its limited to codesize for constant data and to metadata restrictions if its variable.

1.0.3 is available in the package manager, it fixes some bugs but im not sure about yours as it seems not be related to the interpretors but the initialization. If your problems persist could you upload a full log for me?

[ruribev]

Awesome that make a lot of sense. Everything works great now!

I think this is perfect because I am making row operations so for each record I ahve 1 execution and for 1 million rows I end up with 1 million executions witch is excelent for me.

Thanks a lot keep with the good work!