代码

#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
#pragma GCC optimize("-fgcse")
#pragma GCC optimize("-fgcse-lm")
#pragma GCC optimize("-fipa-sra")
#pragma GCC optimize("-ftree-pre")
#pragma GCC optimize("-ftree-vrp")
#pragma GCC optimize("-fpeephole2")
#pragma GCC optimize("-ffast-math")
#pragma GCC optimize("-fsched-spec")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-falign-jumps")
#pragma GCC optimize("-falign-loops")
#pragma GCC optimize("-falign-labels")
#pragma GCC optimize("-fdevirtualize")
#pragma GCC optimize("-fcaller-saves")
#pragma GCC optimize("-fcrossjumping")
#pragma GCC optimize("-fthread-jumps")
#pragma GCC optimize("-funroll-loops")
#pragma GCC optimize("-freorder-blocks")
#pragma GCC optimize("-fschedule-insns")
#pragma GCC optimize("inline-functions")
#pragma GCC optimize("-ftree-tail-merge")
#pragma GCC optimize("-fschedule-insns2")
#pragma GCC optimize("-fstrict-aliasing")
#pragma GCC optimize("-falign-functions")
#pragma GCC optimize("-fcse-follow-jumps")
#pragma GCC optimize("-fsched-interblock")
#pragma GCC optimize("-fpartial-inlining")
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-freorder-functions")
#pragma GCC optimize("-findirect-inlining")
#pragma GCC optimize("-fhoist-adjacent-loads")
#pragma GCC optimize("-frerun-cse-after-loop")
#pragma GCC optimize("inline-small-functions")
#pragma GCC optimize("-finline-small-functions")
#pragma GCC optimize("-ftree-switch-conversion")
#pragma GCC optimize("-foptimize-sibling-calls")
#pragma GCC optimize("-fexpensive-optimizations")
#pragma GCC optimize("inline-functions-called-once")
#pragma GCC optimize("-fdelete-null-pointer-checks")
#define N 100000000
#define D 256
#define D1 255
unsigned *rs[D],t0[D],t1[D],t2[D],t3[D];
void count_t(unsigned*a){
	asm volatile(R"(
		xorl %%ecx,%%ecx
		movl %[a],%%esi
		0:
			movl (%%esi,%%ecx,4),%%eax
			incl %%ecx
			movl (%%esi,%%ecx,4),%%ebx
			incl %%ecx
			
			movzbl %%al,%%edx
			movzbl %%bl,%%edi
			incl %[t0](,%%edx,4)
			incl %[t0](,%%edi,4)
			
			movzbl %%ah,%%edx
			movzbl %%bh,%%edi
			incl %[t1](,%%edx,4)
			incl %[t1](,%%edi,4)
			
			shrl $16,%%eax
			shrl $16,%%ebx
			movzbl %%al,%%edx
			movzbl %%bl,%%edi
			incl %[t2](,%%edx,4)
			incl %[t2](,%%edi,4)
			
			movzbl %%ah,%%edx
			movzbl %%bh,%%edi
			incl %[t3](,%%edx,4)
			incl %[t3](,%%edi,4)
			
			cmpl $100000000,%%ecx
			jne 0b
	)"
	:
	:[a]"m"(a),[t0]"m"(t0),[t1]"m"(t1),[t2]"m"(t2),[t3]"m"(t3)
	:"memory","eax","ebx","ecx","edx","esi","edi"
	); 
}
void sort_0(unsigned*a,unsigned*b){
	rs[0]=b;
	for(int i=1;i<D;++i)rs[i]=rs[i-1]+t0[i-1];
	asm volatile(R"(
		xorl %%ecx,%%ecx
		movl %[a],%%esi
		0:
			movl (%%esi),%%eax
			movl 4(%%esi),%%ebx
			movzbl %%al,%%edx
			movzbl %%bl,%%ebp
			
			movl %[rs](,%%edx,4),%%edi
			movl %%eax,(%%edi)
			addl $4,%[rs](,%%edx,4)
			
			movl %[rs](,%%ebp,4),%%edi
			movl %%ebx,(%%edi)
			addl $4,%[rs](,%%ebp,4)
			
			movl 8(%%esi),%%eax
			movl 12(%%esi),%%ebx
			movzbl %%al,%%edx
			movzbl %%bl,%%ebp
			
			movl %[rs](,%%edx,4),%%edi
			movl %%eax,(%%edi)
			addl $4,%[rs](,%%edx,4)
			
			movl %[rs](,%%ebp,4),%%edi
			movl %%ebx,(%%edi)
			addl $4,%[rs](,%%ebp,4)
			
			addl $16,%%esi
			addl $4,%%ecx
			
			cmpl $100000000,%%ecx
			jne 0b
	)"
	:
	:[a]"m"(a),[t0]"m"(t0),[rs]"m"(rs)
	:"memory","eax","ebx","ecx","edx","esi","edi","ebp"
	);
}
void sort(unsigned*a,int n){
#define cal(w,w2,tw,op) \
p=w2-1;\
for(i=0;i<D;++i)rs[i]=p,p+=tw[i];\
for(i=0;i<N;i+=8){\
	p=w+i;\
	*++rs[p[0]op]=p[0],\
	*++rs[p[1]op]=p[1],\
	*++rs[p[2]op]=p[2],\
	*++rs[p[3]op]=p[3],\
	*++rs[p[4]op]=p[4],\
	*++rs[p[5]op]=p[5],\
	*++rs[p[6]op]=p[6],\
	*++rs[p[7]op]=p[7];\
}
unsigned b[N],*p,i,x;
count_t(a);
sort_0(a,b);
//sort_1(b,a);
//sort_2(a,b);
//sort_3(b,a);
//cal(a,b,t0,&D1);
cal(b,a,t1,>>8&D1);
cal(a,b,t2,>>16&D1);
cal(b,a,t3,>>24);
}

评测结果