RE: code optomization:any way to do this better?

  • From: "Ken Perry" <whistler@xxxxxxxxxxxxx>
  • To: <programmingblind@xxxxxxxxxxxxx>
  • Date: Sun, 16 Jan 2011 23:09:11 -0500


Actuall y you would need to push more than just your data.  You would need
to push data, and location you want to return to for success and a location
you want to return to for fail you don't have to push the location to return
to for fail if its constant but sometimes it's not.  The only other reason
for doing this other than shortening code is to have a debugged section of
code that you knew did one thing correctly.  

Ken


-----Original Message-----
From: programmingblind-bounce@xxxxxxxxxxxxx
[mailto:programmingblind-bounce@xxxxxxxxxxxxx] On Behalf Of Littlefield,
Tyler
Sent: Sunday, January 16, 2011 11:02 PM
To: programmingblind@xxxxxxxxxxxxx
Subject: Re: code optomization:any way to do this better?

The only gain would be in terms of overhead, but it would depend. you 
would have to do it one of two ways:
put the data you wish to check in a register, then jump, or just jump 
and write your code so that the value you wish to check will always be 
in the same register. I'm not really seeing any benafit to this, except 
for in embedded systems where the size of the code matters, and you 
would have to weigh that against the mov+jmp. I am interested to see 
Sina's take on this though. I'd love to start understanding more of how 
this code would be optomised by an assembler, how compilers do their 
optomization, etc.

Earlier this morning I finished up a bootloader, or part of one that 
boots to stage 2. I am finding that I am getting a lot better with the 
internals of things, and have a lot more understanding on how things 
work. I just have a lack of resources to kind of explain what I want to 
learn. So help/explainations/whatever would be really cool.
Thanks for taking a look at that, and for the info.
On 1/16/2011 8:53 PM, Ken Perry wrote:
> I don't think there is a really good way to speed this up.  The fact is
most
> assemblers will turn this into some really optimized machine code and with
> chips now days they can do multiple look ahead if statements so that this
> would almost happen in one pulse of a chips timing. I think Sina might be
> able to talk on the speed of this better than I but I can tell you the
code
> is not bad.  You have to understand  Asm is different than most languages
> because its normal to have some repetitive code.  You could make a block
> that tests for null and returns you to a passed in location so that way
> every time you wanted to test for null you jump to your test block and
then
> if its null jump to end or jump back to the location in the code where you
> wanted to be but I don't see any gain in doing that.
>
> Ken
>
>
> -----Original Message-----
> From: programmingblind-bounce@xxxxxxxxxxxxx
> [mailto:programmingblind-bounce@xxxxxxxxxxxxx] On Behalf Of Littlefield,
> Tyler
> Sent: Sunday, January 16, 2011 9:56 PM
> To: programmingblind@xxxxxxxxxxxxx
> Subject: code optomization:any way to do this better?
>
> So I've been playing with assembly a lot lately, and was curious if
> there was a better way to do this. most importantly, the whole three
> branched if check (null, not null).
> section .text
> global _strcmp
> _strcmp:
> enter 0,0
> ;we copy our arguments to EBX and ECX
> mov EBX, [EBP+8]
> mov ECX, [EBP+12]
> .loop:
> ;we need one value in a register
> mov EDX, [ECX]
> ;check for null termination
> cmp byte [EBX], 0
> je .null
> jne .notnull
> ;we have a null termination.
> ;if the other string is null terminated, we jump to success. otherwise
> it fails because they obviously aren't equal.
> .null:
> cmp byte [ECX], 0
> je .success
> jne .fail
> ;byte wasn't null, now we check for null on the other byte.
> ;if one is null, it's a fail because again they aren't equal. If it is
> not null, we do another check.
> .notnull:
> cmp byte [ECX], 0
> ;not equal, we check for equalness between the two now.
> jne .check
> je .fail
> ;we check for equalness between the two bytes here.
> .check:
> cmp [EBX], EDX
> je .next
> jne .fail
> ;here we increase pointers and jump back up to the top of the loop.
> .next:
> inc EBX
> inc ECX
> jmp .loop
> ;strings compared fully
> .success:
> mov EAX,1
> jmp .finish
> ;strings did not compare fully.
> .fail:
> mov EAX, 0
> ;code cleanup.
> ;no need for a jmp, it just falls through.
> .finish:
> leave
> ret
>


-- 

Thanks,
Ty

__________
View the list's information and change your settings at 
//www.freelists.org/list/programmingblind

__________
View the list's information and change your settings at 
//www.freelists.org/list/programmingblind

Other related posts:

  1. Home
  2. programmingblind
  3. Archive
  4. 01-2011