353 lines
9.9 KiB
ArmAsm
353 lines
9.9 KiB
ArmAsm
|
/*
|
||
|
|
* M7memset.S: SPARC M7 optimized memset.
|
||
|
|
*
|
||
|
|
* Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
|
||
|
|
*/
|
||
|
|
|
||
|
|
/*
|
||
|
|
* M7memset.S: M7 optimized memset.
|
||
|
|
*
|
||
|
|
* char *memset(sp, c, n)
|
||
|
|
*
|
||
|
|
* Set an array of n chars starting at sp to the character c.
|
||
|
|
* Return sp.
|
||
|
|
*
|
||
|
|
* Fast assembler language version of the following C-program for memset
|
||
|
|
* which represents the `standard' for the C-library.
|
||
|
|
*
|
||
|
|
* void *
|
||
|
|
* memset(void *sp1, int c, size_t n)
|
||
|
|
* {
|
||
|
|
* if (n != 0) {
|
||
|
|
* char *sp = sp1;
|
||
|
|
* do {
|
||
|
|
* *sp++ = (char)c;
|
||
|
|
* } while (--n != 0);
|
||
|
|
* }
|
||
|
|
* return (sp1);
|
||
|
|
* }
|
||
|
|
*
|
||
|
|
* The algorithm is as follows :
|
||
|
|
*
|
||
|
|
* For small 6 or fewer bytes stores, bytes will be stored.
|
||
|
|
*
|
||
|
|
* For less than 32 bytes stores, align the address on 4 byte boundary.
|
||
|
|
* Then store as many 4-byte chunks, followed by trailing bytes.
|
||
|
|
*
|
||
|
|
* For sizes greater than 32 bytes, align the address on 8 byte boundary.
|
||
|
|
* if (count >= 64) {
|
||
|
|
* store 8-bytes chunks to align the address on 64 byte boundary
|
||
|
|
* if (value to be set is zero && count >= MIN_ZERO) {
|
||
|
|
* Using BIS stores, set the first long word of each
|
||
|
|
* 64-byte cache line to zero which will also clear the
|
||
|
|
* other seven long words of the cache line.
|
||
|
|
* }
|
||
|
|
* else if (count >= MIN_LOOP) {
|
||
|
|
* Using BIS stores, set the first long word of each of
|
||
|
|
* ST_CHUNK cache lines (64 bytes each) before the main
|
||
|
|
* loop is entered.
|
||
|
|
* In the main loop, continue pre-setting the first long
|
||
|
|
* word of each cache line ST_CHUNK lines in advance while
|
||
|
|
* setting the other seven long words (56 bytes) of each
|
||
|
|
* cache line until fewer than ST_CHUNK*64 bytes remain.
|
||
|
|
* Then set the remaining seven long words of each cache
|
||
|
|
* line that has already had its first long word set.
|
||
|
|
* }
|
||
|
|
* store remaining data in 64-byte chunks until less than
|
||
|
|
* 64 bytes remain.
|
||
|
|
* }
|
||
|
|
* Store as many 8-byte chunks, followed by trailing bytes.
|
||
|
|
*
|
||
|
|
* BIS = Block Init Store
|
||
|
|
* Doing the advance store of the first element of the cache line
|
||
|
|
* initiates the displacement of a cache line while only using a single
|
||
|
|
* instruction in the pipeline. That avoids various pipeline delays,
|
||
|
|
* such as filling the miss buffer. The performance effect is
|
||
|
|
* similar to prefetching for normal stores.
|
||
|
|
* The special case for zero fills runs faster and uses fewer instruction
|
||
|
|
* cycles than the normal memset loop.
|
||
|
|
*
|
||
|
|
* We only use BIS for memset of greater than MIN_LOOP bytes because a sequence
|
||
|
|
* BIS stores must be followed by a membar #StoreStore. The benefit of
|
||
|
|
* the BIS store must be balanced against the cost of the membar operation.
|
||
|
|
*/
|
||
|
|
|
||
|
|
/*
|
||
|
|
* ASI_STBI_P marks the cache line as "least recently used"
|
||
|
|
* which means if many threads are active, it has a high chance
|
||
|
|
* of being pushed out of the cache between the first initializing
|
||
|
|
* store and the final stores.
|
||
|
|
* Thus, we use ASI_STBIMRU_P which marks the cache line as
|
||
|
|
* "most recently used" for all but the last store to the cache line.
|
||
|
|
*/
|
||
|
|
|
||
|
|
#include <asm/asi.h>
|
||
|
|
#include <asm/page.h>
|
||
|
|
|
||
|
|
#define ASI_STBI_P ASI_BLK_INIT_QUAD_LDD_P
|
||
|
|
#define ASI_STBIMRU_P ASI_ST_BLKINIT_MRU_P
|
||
|
|
|
||
|
|
|
||
|
|
#define ST_CHUNK 24 /* multiple of 4 due to loop unrolling */
|
||
|
|
#define MIN_LOOP 16320
|
||
|
|
#define MIN_ZERO 512
|
||
|
|
|
||
|
|
.section ".text"
|
||
|
|
.align 32
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Define clear_page(dest) as memset(dest, 0, PAGE_SIZE)
|
||
|
|
* (can create a more optimized version later.)
|
||
|
|
*/
|
||
|
|
.globl M7clear_page
|
||
|
|
.globl M7clear_user_page
|
||
|
|
M7clear_page: /* clear_page(dest) */
|
||
|
|
M7clear_user_page:
|
||
|
|
set PAGE_SIZE, %o1
|
||
|
|
/* fall through into bzero code */
|
||
|
|
|
||
|
|
.size M7clear_page,.-M7clear_page
|
||
|
|
.size M7clear_user_page,.-M7clear_user_page
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Define bzero(dest, n) as memset(dest, 0, n)
|
||
|
|
* (can create a more optimized version later.)
|
||
|
|
*/
|
||
|
|
.globl M7bzero
|
||
|
|
M7bzero: /* bzero(dest, size) */
|
||
|
|
mov %o1, %o2
|
||
|
|
mov 0, %o1
|
||
|
|
/* fall through into memset code */
|
||
|
|
|
||
|
|
.size M7bzero,.-M7bzero
|
||
|
|
|
||
|
|
.global M7memset
|
||
|
|
.type M7memset, #function
|
||
|
|
.register %g3, #scratch
|
||
|
|
M7memset:
|
||
|
|
mov %o0, %o5 ! copy sp1 before using it
|
||
|
|
cmp %o2, 7 ! if small counts, just write bytes
|
||
|
|
bleu,pn %xcc, .wrchar
|
||
|
|
and %o1, 0xff, %o1 ! o1 is (char)c
|
||
|
|
|
||
|
|
sll %o1, 8, %o3
|
||
|
|
or %o1, %o3, %o1 ! now o1 has 2 bytes of c
|
||
|
|
sll %o1, 16, %o3
|
||
|
|
cmp %o2, 32
|
||
|
|
blu,pn %xcc, .wdalign
|
||
|
|
or %o1, %o3, %o1 ! now o1 has 4 bytes of c
|
||
|
|
|
||
|
|
sllx %o1, 32, %o3
|
||
|
|
or %o1, %o3, %o1 ! now o1 has 8 bytes of c
|
||
|
|
|
||
|
|
.dbalign:
|
||
|
|
andcc %o5, 7, %o3 ! is sp1 aligned on a 8 byte bound?
|
||
|
|
bz,pt %xcc, .blkalign ! already long word aligned
|
||
|
|
sub %o3, 8, %o3 ! -(bytes till long word aligned)
|
||
|
|
|
||
|
|
add %o2, %o3, %o2 ! update o2 with new count
|
||
|
|
! Set -(%o3) bytes till sp1 long word aligned
|
||
|
|
1: stb %o1, [%o5] ! there is at least 1 byte to set
|
||
|
|
inccc %o3 ! byte clearing loop
|
||
|
|
bl,pt %xcc, 1b
|
||
|
|
inc %o5
|
||
|
|
|
||
|
|
! Now sp1 is long word aligned (sp1 is found in %o5)
|
||
|
|
.blkalign:
|
||
|
|
cmp %o2, 64 ! check if there are 64 bytes to set
|
||
|
|
blu,pn %xcc, .wrshort
|
||
|
|
mov %o2, %o3
|
||
|
|
|
||
|
|
andcc %o5, 63, %o3 ! is sp1 block aligned?
|
||
|
|
bz,pt %xcc, .blkwr ! now block aligned
|
||
|
|
sub %o3, 64, %o3 ! o3 is -(bytes till block aligned)
|
||
|
|
add %o2, %o3, %o2 ! o2 is the remainder
|
||
|
|
|
||
|
|
! Store -(%o3) bytes till dst is block (64 byte) aligned.
|
||
|
|
! Use long word stores.
|
||
|
|
! Recall that dst is already long word aligned
|
||
|
|
1:
|
||
|
|
addcc %o3, 8, %o3
|
||
|
|
stx %o1, [%o5]
|
||
|
|
bl,pt %xcc, 1b
|
||
|
|
add %o5, 8, %o5
|
||
|
|
|
||
|
|
! Now sp1 is block aligned
|
||
|
|
.blkwr:
|
||
|
|
andn %o2, 63, %o4 ! calculate size of blocks in bytes
|
||
|
|
brz,pn %o1, .wrzero ! special case if c == 0
|
||
|
|
and %o2, 63, %o3 ! %o3 = bytes left after blk stores.
|
||
|
|
|
||
|
|
set MIN_LOOP, %g1
|
||
|
|
cmp %o4, %g1 ! check there are enough bytes to set
|
||
|
|
blu,pn %xcc, .short_set ! to justify cost of membar
|
||
|
|
! must be > pre-cleared lines
|
||
|
|
nop
|
||
|
|
|
||
|
|
! initial cache-clearing stores
|
||
|
|
! get store pipeline moving
|
||
|
|
rd %asi, %g3 ! save %asi to be restored later
|
||
|
|
wr %g0, ASI_STBIMRU_P, %asi
|
||
|
|
|
||
|
|
! Primary memset loop for large memsets
|
||
|
|
.wr_loop:
|
||
|
|
sub %o5, 8, %o5 ! adjust %o5 for ASI store alignment
|
||
|
|
mov ST_CHUNK, %g1
|
||
|
|
.wr_loop_start:
|
||
|
|
stxa %o1, [%o5+8]%asi
|
||
|
|
subcc %g1, 4, %g1
|
||
|
|
stxa %o1, [%o5+8+64]%asi
|
||
|
|
add %o5, 256, %o5
|
||
|
|
stxa %o1, [%o5+8-128]%asi
|
||
|
|
bgu %xcc, .wr_loop_start
|
||
|
|
stxa %o1, [%o5+8-64]%asi
|
||
|
|
|
||
|
|
sub %o5, ST_CHUNK*64, %o5 ! reset %o5
|
||
|
|
mov ST_CHUNK, %g1
|
||
|
|
|
||
|
|
.wr_loop_rest:
|
||
|
|
stxa %o1, [%o5+8+8]%asi
|
||
|
|
sub %o4, 64, %o4
|
||
|
|
stxa %o1, [%o5+16+8]%asi
|
||
|
|
subcc %g1, 1, %g1
|
||
|
|
stxa %o1, [%o5+24+8]%asi
|
||
|
|
stxa %o1, [%o5+32+8]%asi
|
||
|
|
stxa %o1, [%o5+40+8]%asi
|
||
|
|
add %o5, 64, %o5
|
||
|
|
stxa %o1, [%o5-8]%asi
|
||
|
|
bgu %xcc, .wr_loop_rest
|
||
|
|
stxa %o1, [%o5]ASI_STBI_P
|
||
|
|
|
||
|
|
! If more than ST_CHUNK*64 bytes remain to set, continue
|
||
|
|
! setting the first long word of each cache line in advance
|
||
|
|
! to keep the store pipeline moving.
|
||
|
|
|
||
|
|
cmp %o4, ST_CHUNK*64
|
||
|
|
bge,pt %xcc, .wr_loop_start
|
||
|
|
mov ST_CHUNK, %g1
|
||
|
|
|
||
|
|
brz,a,pn %o4, .asi_done
|
||
|
|
add %o5, 8, %o5 ! restore %o5 offset
|
||
|
|
|
||
|
|
.wr_loop_small:
|
||
|
|
stxa %o1, [%o5+8]%asi
|
||
|
|
stxa %o1, [%o5+8+8]%asi
|
||
|
|
stxa %o1, [%o5+16+8]%asi
|
||
|
|
stxa %o1, [%o5+24+8]%asi
|
||
|
|
stxa %o1, [%o5+32+8]%asi
|
||
|
|
subcc %o4, 64, %o4
|
||
|
|
stxa %o1, [%o5+40+8]%asi
|
||
|
|
add %o5, 64, %o5
|
||
|
|
stxa %o1, [%o5-8]%asi
|
||
|
|
bgu,pt %xcc, .wr_loop_small
|
||
|
|
stxa %o1, [%o5]ASI_STBI_P
|
||
|
|
|
||
|
|
ba .asi_done
|
||
|
|
add %o5, 8, %o5 ! restore %o5 offset
|
||
|
|
|
||
|
|
! Special case loop for zero fill memsets
|
||
|
|
! For each 64 byte cache line, single STBI to first element
|
||
|
|
! clears line
|
||
|
|
.wrzero:
|
||
|
|
cmp %o4, MIN_ZERO ! check if enough bytes to set
|
||
|
|
! to pay %asi + membar cost
|
||
|
|
blu %xcc, .short_set
|
||
|
|
nop
|
||
|
|
sub %o4, 256, %o4
|
||
|
|
|
||
|
|
.wrzero_loop:
|
||
|
|
mov 64, %g3
|
||
|
|
stxa %o1, [%o5]ASI_STBI_P
|
||
|
|
subcc %o4, 256, %o4
|
||
|
|
stxa %o1, [%o5+%g3]ASI_STBI_P
|
||
|
|
add %o5, 256, %o5
|
||
|
|
sub %g3, 192, %g3
|
||
|
|
stxa %o1, [%o5+%g3]ASI_STBI_P
|
||
|
|
add %g3, 64, %g3
|
||
|
|
bge,pt %xcc, .wrzero_loop
|
||
|
|
stxa %o1, [%o5+%g3]ASI_STBI_P
|
||
|
|
add %o4, 256, %o4
|
||
|
|
|
||
|
|
brz,pn %o4, .bsi_done
|
||
|
|
nop
|
||
|
|
|
||
|
|
.wrzero_small:
|
||
|
|
stxa %o1, [%o5]ASI_STBI_P
|
||
|
|
subcc %o4, 64, %o4
|
||
|
|
bgu,pt %xcc, .wrzero_small
|
||
|
|
add %o5, 64, %o5
|
||
|
|
ba,a .bsi_done
|
||
|
|
|
||
|
|
.asi_done:
|
||
|
|
wr %g3, 0x0, %asi ! restored saved %asi
|
||
|
|
.bsi_done:
|
||
|
|
membar #StoreStore ! required by use of Block Store Init
|
||
|
|
|
||
|
|
.short_set:
|
||
|
|
cmp %o4, 64 ! check if 64 bytes to set
|
||
|
|
blu %xcc, 5f
|
||
|
|
nop
|
||
|
|
4: ! set final blocks of 64 bytes
|
||
|
|
stx %o1, [%o5]
|
||
|
|
stx %o1, [%o5+8]
|
||
|
|
stx %o1, [%o5+16]
|
||
|
|
stx %o1, [%o5+24]
|
||
|
|
subcc %o4, 64, %o4
|
||
|
|
stx %o1, [%o5+32]
|
||
|
|
stx %o1, [%o5+40]
|
||
|
|
add %o5, 64, %o5
|
||
|
|
stx %o1, [%o5-16]
|
||
|
|
bgu,pt %xcc, 4b
|
||
|
|
stx %o1, [%o5-8]
|
||
|
|
|
||
|
|
5:
|
||
|
|
! Set the remaining long words
|
||
|
|
.wrshort:
|
||
|
|
subcc %o3, 8, %o3 ! Can we store any long words?
|
||
|
|
blu,pn %xcc, .wrchars
|
||
|
|
and %o2, 7, %o2 ! calc bytes left after long words
|
||
|
|
6:
|
||
|
|
subcc %o3, 8, %o3
|
||
|
|
stx %o1, [%o5] ! store the long words
|
||
|
|
bgeu,pt %xcc, 6b
|
||
|
|
add %o5, 8, %o5
|
||
|
|
|
||
|
|
.wrchars: ! check for extra chars
|
||
|
|
brnz %o2, .wrfin
|
||
|
|
nop
|
||
|
|
retl
|
||
|
|
nop
|
||
|
|
|
||
|
|
.wdalign:
|
||
|
|
andcc %o5, 3, %o3 ! is sp1 aligned on a word boundary
|
||
|
|
bz,pn %xcc, .wrword
|
||
|
|
andn %o2, 3, %o3 ! create word sized count in %o3
|
||
|
|
|
||
|
|
dec %o2 ! decrement count
|
||
|
|
stb %o1, [%o5] ! clear a byte
|
||
|
|
b .wdalign
|
||
|
|
inc %o5 ! next byte
|
||
|
|
|
||
|
|
.wrword:
|
||
|
|
subcc %o3, 4, %o3
|
||
|
|
st %o1, [%o5] ! 4-byte writing loop
|
||
|
|
bnz,pt %xcc, .wrword
|
||
|
|
add %o5, 4, %o5
|
||
|
|
|
||
|
|
and %o2, 3, %o2 ! leftover count, if any
|
||
|
|
|
||
|
|
.wrchar:
|
||
|
|
! Set the remaining bytes, if any
|
||
|
|
brz %o2, .exit
|
||
|
|
nop
|
||
|
|
.wrfin:
|
||
|
|
deccc %o2
|
||
|
|
stb %o1, [%o5]
|
||
|
|
bgu,pt %xcc, .wrfin
|
||
|
|
inc %o5
|
||
|
|
.exit:
|
||
|
|
retl ! %o0 was preserved
|
||
|
|
nop
|
||
|
|
|
||
|
|
.size M7memset,.-M7memset
|