BLAST v1.0.4

[nijnstein]

BLAST Version v1.0.4 has been uploaded to unity and will be released shortly.

This update contains some bugfixes and a large refactor of indexed assignments and introduces CDATA sections. This refactor reduces branching controlflow concerning assignments. CDATA sections provide constant size data segments in the codestream (and with v1.0.5 in the datasegment) providing a backing for typed array data.

Setting and indexing numeric data:

#cdata a 1 2 3 4 5 6 7 8; 
validate(a[7], 8);
a[1] = 22; 
validate(a[1], 22); 
b = size(a); 
validate(b, 8)

Setting ASCII or Binary data:

#cdata msg "abcd";
#cdata a = 11110000_11001100_11110000_11001100 11110000_11001100_11110000_11001111; 

send(msg);  # sends to log for now, we might allow to sink this

In order to write to CDATA the compiler should enable the SHARED_DATA setting: #define SHARED_CDATA 1 as for normal use CDATA is considered constant when located in the codesegment, it could however be used to share data between executions of script. Future versions of Blast will use CDATA to implement various features.

Release Notes:

• bugfix: fixed bug causing error in sample6 dueue to a wrong check in packaging
• bugfix: fixed bug tracking vectorsizes during compilation
• added: unity assembly definition file reducing editor re-build times

NORMAL PACKAGEMODE

• added: constant cdata sections providing fixed arrays
• added: array [] indexers
• optimized: reduced controlflow interpreting (indexed) assignments

[nijnstein]

BLAST v1.0.4b

• Stricter compilation
• Stability improvements dueue to strictness
• Many small bugs fixed.
• Added references to burst and mathematics libraries in the assembly definition.
• Refactored SSMD interpretor, depending on the script the improvements range from 0.8x to over 10x performance gains in vector calculations.

[nijnstein]

BLAST v1.0.4c

• Performance: Ensured propper vectorization in most arithmetic loops in while compiled for burst while keeping a proper mapping for the normal .net compiler to produre vectorized output.

Alignment

When blast encounters the following equation: a = a * b * 4, the depending on alignment or not the following assembly is executed in burst (only important parts are shown)

**Aligned float * float **

To perform the multiplication between 2 variables in a datasegment that is aligned:

**Register float * constant **
The result is multiplied in a register (of the interpretor) with a constant, blast knows to only execute the move once for all records combined, in future versions, for ssmd, values will be constant when they are equal accross all records in the input. This will bring big optimizations not normally possible with pre-compiled code.

The datasegment and stack are setup as arrays of arrays and are said to be aligned when each basepointer of the subarrays has the same offset to the other. If thats not the case we call the data unaligned and blast has to calculate each base index resuling in un-packed instructions but still very fast code:

And thats it, the above script executes in 1.7 ns on my machine if i feed it 64 data records.

[nijnstein]

1.0.4c

Blast gets close to the maximum floating point capability of my cpu, the first tests test the fast array loops for operations (only mul for brevity), these compile into avx instructions and in most tests its only 20% slower to use blast to perform the same calculations in script:

BLAST 1.0.4c is much faster then the initial release due to the use of specialized routines for many operations that mostly map perfectly to simd assembly depending on your compiler:

        /// <summary>
        /// [][].xy = a.xy / -b.x
        /// </summary>
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        static public void div_array_f2f1_n([NoAlias] float4* a, [NoAlias] float4* b, in DATAREC target, in int ssmd_datacount)
        {
            float* p = target.index00;
            int p_stride = target.row_size >> 2;

            if (IsUnrolled)
            {
                float* fa = (float*)(void*)a;
                float* fb = (float*)(void*)b;
                int i = 0;

                while (i < (ssmd_datacount & ~3))
                {
                    p[0] = fa[0] / -fb[0];
                    p[1] = fa[1] / -fb[0];
                    p += p_stride;

                    p[0] = fa[4] / -fb[4];
                    p[1] = fa[5] / -fb[4];
                    p += p_stride;

                    p[0] = fa[8] / -fb[8];
                    p[1] = fa[9] / -fb[8];
                    p += p_stride;

                    p[0] = fa[12] / -fb[12];
                    p[1] = fa[13] / -fb[12];
                    p += p_stride;

                    fa += 16;
                    fb += 16;
                    i += 4;
                }

                while (i < ssmd_datacount)
                {
                    p[0] = fa[0] / -fb[0];
                    p[1] = fa[1] / -fb[0];
                    p += p_stride;
                    fa += 4;
                    fb += 4;
                    i++;
                }
            }
            else
            {
                for (int i = 0; i < ssmd_datacount; i++)
                {
                    float f = -b[i].x;
                    p[0] = a[i].x / f;
                    p[1] = a[i].y / f;
                    p += p_stride;
                }
            }
        }

These build to very fast code in .net but with burst are guaranteed to be vectorized on hardware that supports it.

The latest build passes all unittests

And will be made available from the assetstore after unity's review shortly.

[nijnstein]

Blast 1.0.4d introduces codegen for handling external function definitions.

Blast can be configured to accept different 255 delegate types mapped to external functions. You can configure the profiles in the blastscriptapi for any pattern up to 8 parameters:

            CreateExternalProfile(BlastVectorSizes.none,   false, false);
            CreateExternalProfile(BlastVectorSizes.float1, false, false, BlastVectorSizes.float1);
            CreateExternalProfile(BlastVectorSizes.float1, false, false, BlastVectorSizes.float1, BlastVectorSizes.float1);
            CreateExternalProfile(BlastVectorSizes.float1, false, false, BlastVectorSizes.float1, BlastVectorSizes.float1, BlastVectorSizes.float1);
            CreateExternalProfile(BlastVectorSizes.float1, false, false, BlastVectorSizes.float2);
            CreateExternalProfile(BlastVectorSizes.float1, false, false, BlastVectorSizes.float2, BlastVectorSizes.float2);
            CreateExternalProfile(BlastVectorSizes.float1, false, false, BlastVectorSizes.float2, BlastVectorSizes.float2, BlastVectorSizes.float2);
            CreateExternalProfile(BlastVectorSizes.float1, false, false, BlastVectorSizes.float3);
            CreateExternalProfile(BlastVectorSizes.float1, false, false, BlastVectorSizes.float3, BlastVectorSizes.float3);
            CreateExternalProfile(BlastVectorSizes.float1, false, false, BlastVectorSizes.float3, BlastVectorSizes.float3, BlastVectorSizes.float3);
            CreateExternalProfile(BlastVectorSizes.float1, false, false, BlastVectorSizes.float4);
            CreateExternalProfile(BlastVectorSizes.float1, false, false, BlastVectorSizes.float4, BlastVectorSizes.float4);
            CreateExternalProfile(BlastVectorSizes.float1, false, false, BlastVectorSizes.float4, BlastVectorSizes.float4, BlastVectorSizes.float4);
            CreateExternalProfile(BlastVectorSizes.float2, false, false, BlastVectorSizes.float2);
            CreateExternalProfile(BlastVectorSizes.float3, false, false, BlastVectorSizes.float3);
            CreateExternalProfile(BlastVectorSizes.float4, false, false, BlastVectorSizes.float4);
            CreateExternalProfile(BlastVectorSizes.none,   false, false, BlastVectorSizes.bool32);
            CreateExternalProfile(BlastVectorSizes.bool32, false, false, BlastVectorSizes.bool32);

Upon compilation|editor rebuild, blast will generate parts of its own code so it can handle various function pointer types natively, cleanly with maximum performance in burst compiled code.

Registration is easy in code:

        [BurstCompatible]
        static public float ExternalTest(IntPtr blast, IntPtr env, IntPtr caller, float a, float b)
        {
            return a * b; 
        }

        Blast.ScriptAPI.Register(ExternalTest);

Scriptcode to use the external:

#input value float 0\nresult = value + ExternalTest(2, 3);"

This will be included in the next asset store release in which an editor will also be included to setup blast for its specifik environment.

[nijnstein]

The generation of blasts code for handling generics gives a huge payof giving cleaner code and a more direct functioncall for each external invocation. without codegeneration it would not be possible to have a configurable function protottype for native external functions.