andps    xmm1,dqword [unsignmask]    

cpeqps    xmm2,xmm2
psrld    xmm2
andps    xmm1,xmm2    

What I don't understand, is why movaps xmm,[m128] doesn't cause any speed hit over movaps xmm,xmm. I thought memory access was supposed to be a bottleneck, but that does not appear to be the case. I'm running at 4GHz with 1880MHz RAM.

I think the quality of hand-optimized code could be much more expedient if there were an interactive assembler with a visual indication of pipelines, timings and latencies, drawing from multiple sources. Like the information HLL's use to optimize code except show it to the coder intuitively so they have control over the pipelines.

I had thought that as long as you can fill up the latencies with meaningful parallel computations, the instructions should only take as long as their timing cycles. But I found that switching to instructions with minimal latencies, with lenience towards clock cycles, actually brought the largest improvements in speed.

keantoken wrote:

I think the quality of hand-optimized code could be much more expedient if there were an interactive assembler with a visual indication of pipelines, timings and latencies, drawing from multiple sources. Like the information HLL's use to optimize code except show it to the coder intuitively so they have control over the pipelines.

That would be almost impossible with any modern CPU. No software system could know the precise internal state of the CPU. Timing predictions would be meaningless, or at the very least, very inaccurate.

Splitting the image into tiles was my first instinct when I thought about using multi-core. However different parts of an image render at different speeds so some threads may lag behind. So it seems you would want to have a way for the slowest thread to fork if another thread finishes soon so the extra core can be recycled.

;----------------
; Graph
;
; Plots data and labels axes in a compact, minimalistic style
;
; Features:
;
; Plotting:
; 1: per-axis modes: anti-aliased, nearest
; 2: Connect mode
;       a: straight or curve (FFT interpolation; periodic FFT for periodic data such as phase)
; 3: Space mode
;       b: voronoi
; 4: Animations
; 5: background image/watermark
; 6: triggered area shading
;
; Axes:
; 1: Simple pixel font alphanumeric labels; vertical or horizontal
;       a: vertical, horizontal, or axis-aligned perpendicular or parallel
;       b: staggering
;       c: label rout packing w/staggering
;       d: superscript and subscript
;       e: on-plot point labels
;       f: transparent labels
;       g: label type: integer, fraction (reciprocal), ratio, normalized, exponent (scientific, engineering (mnemonic, exponent))
; 2: Flexible tick marks
; 3: Linear, logarithmic
;       a: octave, decade, decibel
; 4: 2 spatial dimensions; further dimensions via multiple lines or color
; 5: Modes:
; 6: Domain flag
; 7:
;
; Coordinates:
; 1: Cartesian, polar, multi-polar (modular?)
;       a: phase-wrap for polar and color representation of phase
;
; Modules:
; 1: Datatype specific transforms (hist, FFT, polar->cart) available through their respective modules
;
; Post-processing
; 1: blank border of specified pixels
; 2: integer resizing (x2, x4...)


format ELF64 executable 3
entry Main

Plot:
        ; Step domain until all data points are collected

        X       = r15
        Y       = r14
        Wxyps   = xmm0
        RGBps   = xmm1
        Spx     = dqword [Xpx]
; Initiate scanloop

        mov     Y,[Ypx]
; Start scanloop
Scan:
        mov     X,[Xpx]
.X:
        ; For ever pixel, its position is subtracted from that of every window point, and if it is farther than a pixel away from any point, it is skipped
                ; distance; |W(x,y)-P(x,y)|
                ; skip if further than a pixel away
                cmpltps
                movq    rdx,
                cmp     rdx,[ffffffffps]
                je      @f
                ; For AA:
                ; RGB% = 1-|W(x,y)-P(x,y)|/GPP
                rcpss                           ; 1.5*10**-11 accuracy; 11 or 12 bits
                mulss                           ; rcp->mul is a fast approximation of div. In an image you won't notice the difference, but you may notice the speedup.
                subss                           ; minus or plus 255 for black-on-white or white-on-black
                ; Convert to RGBA
                pshufb  RGBps,[RGBAmaskps]       ; format conversion
                movd    eax,RGBps

        @@:
        ; Store computed value
        mov     [edi],eax                       ; Will using eax clear all 64-bit registers or just rax?
        xor     eax,eax                         ; in case the next pixel is skipped and this value is left in eax
        ; Bump pixel coordinates and window coordinates
        andps   Wxyps,
        dec     X
        jnz     .X

        add     Wy,[GPPy]
        dec     Y
        jnz     Scan

; Trigger point labels and store coordinates on stack
        return

Label:
; calculate plot label sizes
        ; clipped labels trigger warning if image size is specified
; Process point label triggers on stack.
        return

Main:
; Calculate image metrics
        ; plot section
                ; Pixel resolution
                ; grid points per pixel (Pixel length or GPP)
                        ; plot size (px) / window size = pixel length
; mmap image size
; Render plot
        call    plot
; Render axes/labels
        call    Label
; Combine plot and labels
        ; Shift plot up and to the right

                            

long clone(unsigned long flags, void* child_stack, int* ptid, int* ctid, unsigned long newtls);    

mov eax, 56          ; should be sys_clone
mov edi, 0x00110F00  ; CLONE_VM | CLONE_THREAD | CLONE_FS | CLONE_FILES | CLONE_SIGHAND | CLONE_PARENT_SETTID
mov rsi, end_of_allocated_stack
lea rdx, [rsp+ptid]  ; assuming it's a local variable, change it as needed
syscall