[Back to MEMORY SWAG index]  [Back to Main SWAG index]  [Original]

{
> >If anyone wants to see my "improved" move() and fillchar() which I put
> >into a unit which I almost always link in I'd be happy to post it.  (I
> >know that TCA has an even better one though, in case he'd like to post
> >his version as well)
>
> Oh, fine.  Now that the world knows, I suppose I have to post it ;)
>
Thank you for so graciously accepting the terms before anyone wanted me
to post my much more elementary 16-bit version as below:
}
procedure move (var src, dest; count : word); assembler;

asm
  push ds
    mov bx, count
    mov cx, bx
    shr cx, 1

    les di, src
    lds si, dest
    rep movsw

    and bx, 1
    jz @NoMovsB
    movsb
   @NoMovsB: 

  pop ds
end;

> This is a 32bit move() replacement.  Just throw the procedure in at the 
> top of your program, and all your move() calls will work a little faster
> (about 4 times faster for counts above 128 bytes).
> 
> procedure move(var Source,Dest; Count:word); assembler;
> asm
> 	push	ds
> 	les	di,Dest
> 	lds	si,Source
> 	mov	cx,count
> 	mov	bx,cx
> 	shr	cx,2
> 	db 66h;	rep movsw
> 	and	bx,3
> 	mov	cx,bx
> 	rep	movsb
> 	pop	ds
> end;
>
I remember yours looking a little different then that, maybe I'm thinking 
of fillchar (later on)... but not to be picky, since dx isn't used, 
couldn't you use mov dx, ds and mov ds, dx instead of push and pop 
respectively?

> The fillchar() replacement isn't as nice, since with fillchar you can do 
> things like: fillchar(foo,128,'H'); or fillchar(foo,128,TRUE);  
> That makes conversions more difficult.  Still, for those of you who don't 
> do that:
> 
> procedure fillchar(var X; Count:word; Value:byte); assembler;
> asm
> 	les	di,X
> 	mov	cx,count
> 	mov	al,value
> 	mov	ah,al
> 	mov	bx,ax
> 	db 66h;	shl ax,16
> 	mov	ax,bx
> 	mov	bx,cx
> 	shr	cx,2
> 	db 66h; rep stosw
> 	and	bx,3
> 	mov	cx,bx
> 	rep	stosb
> end;
> 
Hmmm... you must have rewritten both of them since I last saw them, as I 
remember something utilizing adc in one of those... oh well, thse look 
more logical anyway :)

> To get around the character or boolean types, do ord('H') or ord(TRUE).
> (It all compiles to the same code).
> 
> This procedure will only increase the speed of fillchar() calls when the 
> Count is above 128 or so.  It will also fillchar to pointers faster than 
> arrays (since pointers are aligned, and arrays are [usually] not).  I 
> just wrote the fillchar() procedure, so it is not as optimized as it
> could be.
> 
How about I put up my fillchar as well, just for comparison's sake (it's, 
once again, only 16-bit, but it seems to work just fine anyway :)

procedure FillChar (var src, dest; count : word; value : byte); assembler;

asm
  mov bx, count
  mov cx, bx
  shr cx, 1

  mov al, value
  mov ah, al

  les di, dest
  rep stosw

  and bx, 1
  jz @NoStosB
  stosb
 @NoStosB:
end;

In other words it's my move() only with ax = 257*value and, well, a fill
instead of a move. :)

[Back to MEMORY SWAG index]  [Back to Main SWAG index]  [Original]