mmx for dropshadwo.. but disabled for now


			
			
				devs/princeamd/enlightenment-0.17-elive
			
			
		
Carsten Haitzler 18 years ago
parent b250d3f527
commit d9142c3024
  1. 5
      TODO
  2. 1
      src/bin/Makefile.am
  3. 1
      src/bin/e_border.c
  4. 1
      src/bin/e_includes.h
  5. 644
      src/bin/e_mmx.h
  6. 109
      src/modules/dropshadow/e_mod_main.c

@ -40,6 +40,9 @@ Some of the things (in very short form) that need to be done to E17...
ESSENTIAL FEATURES
-------------------------------------------------------------------------------
* shaded windows should not allow border changes by the user
* if a border is borderless it should not be allowed to be shaded (padl/r/t/b
is 0)
* add fullscreen support (e16 xvidmode or xrandr style)
* implement thses maximise/fullscreen modes:
Which of these should be different modes, and which should be options for
@ -199,8 +202,6 @@ Some of the things (in very short form) that need to be done to E17...
OPTIMISATIONS
-------------------------------------------------------------------------------
* could speedup dropshadow's gaussian blurr with mmx and sse by doign 2 or 4
rows at once
* optimize clock theme (speed/cpu) (rotation in edje??? or evas???)
]]]

@ -12,6 +12,7 @@ bin_PROGRAMS = enlightenment enlightenment_remote enlightenment_eapp
ENLIGHTENMENTHEADERS = \
e.h \
e_includes.h \
e_mmx.h \
e_ipc_handlers.h \
e_ipc_handlers_list.h \
e_user.h \

@ -4886,6 +4886,7 @@ _e_border_menu_show(E_Border *bd, Evas_Coord x, Evas_Coord y, int key)
e_menu_item_toggle_set(mi, bd->var); \
e_menu_item_callback_set(mi, _e_border_menu_cb_##var, bd);
/* FIXME: 1 big menu right now - mayeb layer make it 3 submenus? */
NEW_LOCK_MI("Position (User)", lock_user_location);
NEW_LOCK_MI("Size (User)", lock_user_size);
NEW_LOCK_MI("Stacking (User)", lock_user_stacking);

@ -1,6 +1,7 @@
/*
* vim:ts=8:sw=3:sts=8:noexpandtab:cino=>5n-3f0^-2{2
*/
#include "e_mmx.h"
#include "e_object.h"
#include "e_user.h"
#include "e_manager.h"

@ -0,0 +1,644 @@
/* mmx.h
MultiMedia eXtensions GCC interface library for IA32.
To use this library, simply include this header file
and compile with GCC. You MUST have inlining enabled
in order for mmx_ok() to work; this can be done by
simply using -O on the GCC command line.
Compiling with -DMMX_TRACE will cause detailed trace
output to be sent to stderr for each mmx operation.
This adds lots of code, and obviously slows execution to
a crawl, but can be very useful for debugging.
THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, WITHOUT
LIMITATION, THE IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS FOR ANY PARTICULAR PURPOSE.
1997-98 by H. Dietz and R. Fisher
History:
97-98* R.Fisher Early versions
980501 R.Fisher Original Release
980611* H.Dietz Rewrite, correctly implementing inlines, and
R.Fisher including direct register accesses.
980616 R.Fisher Release of 980611 as 980616.
980714 R.Fisher Minor corrections to Makefile, etc.
980715 R.Fisher mmx_ok() now prevents optimizer from using
clobbered values.
mmx_ok() now checks if cpuid instruction is
available before trying to use it.
980726* R.Fisher mm_support() searches for AMD 3DNow, Cyrix
Extended MMX, and standard MMX. It returns a
value which is positive if any of these are
supported, and can be masked with constants to
see which. mmx_ok() is now a call to this
980726* R.Fisher Added i2r support for shift functions
980919 R.Fisher Fixed AMD extended feature recognition bug.
980921 R.Fisher Added definition/check for _MMX_H.
Added "float s[2]" to mmx_t for use with
3DNow and EMMX. So same mmx_t can be used.
981013 R.Fisher Fixed cpuid function 1 bug (looked at wrong reg)
Fixed psllq_i2r error in mmxtest.c
* Unreleased (internal or interim) versions
Notes:
It appears that the latest gas has the pand problem fixed, therefore
I'll undefine BROKEN_PAND by default.
String compares may be quicker than the multiple test/jumps in vendor
test sequence in mmx_ok(), but I'm not concerned with that right now.
Acknowledgments:
Jussi Laako for pointing out the errors ultimately found to be
connected to the failure to notify the optimizer of clobbered values.
Roger Hardiman for reminding us that CPUID isn't everywhere, and that
someone may actually try to use this on a machine without CPUID.
Also for suggesting code for checking this.
Robert Dale for pointing out the AMD recognition bug.
Jimmy Mayfield and Carl Witty for pointing out the Intel recognition
bug.
Carl Witty for pointing out the psllq_i2r test bug.
*/
#ifndef _MMX_H
#define _MMX_H
/* Warning: at this writing, the version of GAS packaged
with most Linux distributions does not handle the
parallel AND operation mnemonic correctly. If the
symbol BROKEN_PAND is defined, a slower alternative
coding will be used. If execution of mmxtest results
in an illegal instruction fault, define this symbol.
*/
#undef BROKEN_PAND
/* The type of an value that fits in an MMX register
(note that long long constant values MUST be suffixed
by LL and unsigned long long values by ULL, lest
they be truncated by the compiler)
*/
typedef union {
long long q; /* Quadword (64-bit) value */
unsigned long long uq; /* Unsigned Quadword */
int d[2]; /* 2 Doubleword (32-bit) values */
unsigned int ud[2]; /* 2 Unsigned Doubleword */
short w[4]; /* 4 Word (16-bit) values */
unsigned short uw[4]; /* 4 Unsigned Word */
char b[8]; /* 8 Byte (8-bit) values */
unsigned char ub[8]; /* 8 Unsigned Byte */
float s[2]; /* Single-precision (32-bit) value */
} __attribute__ ((aligned (8))) mmx_t;
/* Helper functions for the instruction macros that follow...
(note that memory-to-register, m2r, instructions are nearly
as efficient as register-to-register, r2r, instructions;
however, memory-to-memory instructions are really simulated
as a convenience, and are only 1/3 as efficient)
*/
/* These macros are a lot simpler without the tracing...
*/
#define mmx_i2r(op, imm, reg) \
__asm__ __volatile__ (#op " $" #imm ", %%" #reg \
: /* nothing */ \
: /* nothing */);
#define mmx_m2r(op, mem, reg) \
__asm__ __volatile__ (#op " %0, %%" #reg \
: /* nothing */ \
: "m" (mem))
#define mmx_r2m(op, reg, mem) \
__asm__ __volatile__ (#op " %%" #reg ", %0" \
: "=m" (mem) \
: /* nothing */ )
#define mmx_r2r(op, regs, regd) \
__asm__ __volatile__ (#op " %" #regs ", %" #regd)
#define mmx_m2m(op, mems, memd) \
__asm__ __volatile__ ("movq %0, %%mm0\n\t" \
#op " %1, %%mm0\n\t" \
"movq %%mm0, %0" \
: "=m" (memd) \
: "m" (mems))
/* 1x64 MOVe Quadword
(this is both a load and a store...
in fact, it is the only way to store)
*/
#define movq_m2r(var, reg) mmx_m2r(movq, var, reg)
#define movq_r2m(reg, var) mmx_r2m(movq, reg, var)
#define movq_r2r(regs, regd) mmx_r2r(movq, regs, regd)
#define movq(vars, vard) \
__asm__ __volatile__ ("movq %1, %%mm0\n\t" \
"movq %%mm0, %0" \
: "=m" (vard) \
: "m" (vars))
#define movntq_r2m(reg, var) mmx_r2m(movntq, reg, var)
/* 1x32 MOVe Doubleword
(like movq, this is both load and store...
but is most useful for moving things between
mmx registers and ordinary registers)
*/
#define movd_m2r(var, reg) mmx_m2r(movd, var, reg)
#define movd_r2m(reg, var) mmx_r2m(movd, reg, var)
#define movd_r2r(regs, regd) mmx_r2r(movd, regs, regd)
#define movd(vars, vard) \
__asm__ __volatile__ ("movd %1, %%mm0\n\t" \
"movd %%mm0, %0" \
: "=m" (vard) \
: "m" (vars))
/* 2x32, 4x16, and 8x8 Parallel ADDs
*/
#define paddd_m2r(var, reg) mmx_m2r(paddd, var, reg)
#define paddd_r2r(regs, regd) mmx_r2r(paddd, regs, regd)
#define paddd(vars, vard) mmx_m2m(paddd, vars, vard)
#define paddw_m2r(var, reg) mmx_m2r(paddw, var, reg)
#define paddw_r2r(regs, regd) mmx_r2r(paddw, regs, regd)
#define paddw(vars, vard) mmx_m2m(paddw, vars, vard)
#define paddb_m2r(var, reg) mmx_m2r(paddb, var, reg)
#define paddb_r2r(regs, regd) mmx_r2r(paddb, regs, regd)
#define paddb(vars, vard) mmx_m2m(paddb, vars, vard)
/* 4x16 and 8x8 Parallel ADDs using Saturation arithmetic
*/
#define paddsw_m2r(var, reg) mmx_m2r(paddsw, var, reg)
#define paddsw_r2r(regs, regd) mmx_r2r(paddsw, regs, regd)
#define paddsw(vars, vard) mmx_m2m(paddsw, vars, vard)
#define paddsb_m2r(var, reg) mmx_m2r(paddsb, var, reg)
#define paddsb_r2r(regs, regd) mmx_r2r(paddsb, regs, regd)
#define paddsb(vars, vard) mmx_m2m(paddsb, vars, vard)
/* 4x16 and 8x8 Parallel ADDs using Unsigned Saturation arithmetic
*/
#define paddusw_m2r(var, reg) mmx_m2r(paddusw, var, reg)
#define paddusw_r2r(regs, regd) mmx_r2r(paddusw, regs, regd)
#define paddusw(vars, vard) mmx_m2m(paddusw, vars, vard)
#define paddusb_m2r(var, reg) mmx_m2r(paddusb, var, reg)
#define paddusb_r2r(regs, regd) mmx_r2r(paddusb, regs, regd)
#define paddusb(vars, vard) mmx_m2m(paddusb, vars, vard)
/* 2x32, 4x16, and 8x8 Parallel SUBs
*/
#define psubd_m2r(var, reg) mmx_m2r(psubd, var, reg)
#define psubd_r2r(regs, regd) mmx_r2r(psubd, regs, regd)
#define psubd(vars, vard) mmx_m2m(psubd, vars, vard)
#define psubw_m2r(var, reg) mmx_m2r(psubw, var, reg)
#define psubw_r2r(regs, regd) mmx_r2r(psubw, regs, regd)
#define psubw(vars, vard) mmx_m2m(psubw, vars, vard)
#define psubb_m2r(var, reg) mmx_m2r(psubb, var, reg)
#define psubb_r2r(regs, regd) mmx_r2r(psubb, regs, regd)
#define psubb(vars, vard) mmx_m2m(psubb, vars, vard)
/* 4x16 and 8x8 Parallel SUBs using Saturation arithmetic
*/
#define psubsw_m2r(var, reg) mmx_m2r(psubsw, var, reg)
#define psubsw_r2r(regs, regd) mmx_r2r(psubsw, regs, regd)
#define psubsw(vars, vard) mmx_m2m(psubsw, vars, vard)
#define psubsb_m2r(var, reg) mmx_m2r(psubsb, var, reg)
#define psubsb_r2r(regs, regd) mmx_r2r(psubsb, regs, regd)
#define psubsb(vars, vard) mmx_m2m(psubsb, vars, vard)
/* 4x16 and 8x8 Parallel SUBs using Unsigned Saturation arithmetic
*/
#define psubusw_m2r(var, reg) mmx_m2r(psubusw, var, reg)
#define psubusw_r2r(regs, regd) mmx_r2r(psubusw, regs, regd)
#define psubusw(vars, vard) mmx_m2m(psubusw, vars, vard)
#define psubusb_m2r(var, reg) mmx_m2r(psubusb, var, reg)
#define psubusb_r2r(regs, regd) mmx_r2r(psubusb, regs, regd)
#define psubusb(vars, vard) mmx_m2m(psubusb, vars, vard)
/* 4x16 Parallel MULs giving Low 4x16 portions of results
*/
#define pmullw_m2r(var, reg) mmx_m2r(pmullw, var, reg)
#define pmullw_r2r(regs, regd) mmx_r2r(pmullw, regs, regd)
#define pmullw(vars, vard) mmx_m2m(pmullw, vars, vard)
/* 4x16 Parallel MULs giving High 4x16 portions of results
*/
#define pmulhw_m2r(var, reg) mmx_m2r(pmulhw, var, reg)
#define pmulhw_r2r(regs, regd) mmx_r2r(pmulhw, regs, regd)
#define pmulhw(vars, vard) mmx_m2m(pmulhw, vars, vard)
/* 4x16->2x32 Parallel Mul-ADD
(muls like pmullw, then adds adjacent 16-bit fields
in the multiply result to make the final 2x32 result)
*/
#define pmaddwd_m2r(var, reg) mmx_m2r(pmaddwd, var, reg)
#define pmaddwd_r2r(regs, regd) mmx_r2r(pmaddwd, regs, regd)
#define pmaddwd(vars, vard) mmx_m2m(pmaddwd, vars, vard)
/* 1x64 bitwise AND
*/
#ifdef BROKEN_PAND
#define pand_m2r(var, reg) \
{ \
mmx_m2r(pandn, (mmx_t) -1LL, reg); \
mmx_m2r(pandn, var, reg); \
}
#define pand_r2r(regs, regd) \
{ \
mmx_m2r(pandn, (mmx_t) -1LL, regd); \
mmx_r2r(pandn, regs, regd) \
}
#define pand(vars, vard) \
{ \
movq_m2r(vard, mm0); \
mmx_m2r(pandn, (mmx_t) -1LL, mm0); \
mmx_m2r(pandn, vars, mm0); \
movq_r2m(mm0, vard); \
}
#else
#define pand_m2r(var, reg) mmx_m2r(pand, var, reg)
#define pand_r2r(regs, regd) mmx_r2r(pand, regs, regd)
#define pand(vars, vard) mmx_m2m(pand, vars, vard)
#endif
/* 1x64 bitwise AND with Not the destination
*/
#define pandn_m2r(var, reg) mmx_m2r(pandn, var, reg)
#define pandn_r2r(regs, regd) mmx_r2r(pandn, regs, regd)
#define pandn(vars, vard) mmx_m2m(pandn, vars, vard)
/* 1x64 bitwise OR
*/
#define por_m2r(var, reg) mmx_m2r(por, var, reg)
#define por_r2r(regs, regd) mmx_r2r(por, regs, regd)
#define por(vars, vard) mmx_m2m(por, vars, vard)
/* 1x64 bitwise eXclusive OR
*/
#define pxor_m2r(var, reg) mmx_m2r(pxor, var, reg)
#define pxor_r2r(regs, regd) mmx_r2r(pxor, regs, regd)
#define pxor(vars, vard) mmx_m2m(pxor, vars, vard)
/* 2x32, 4x16, and 8x8 Parallel CoMPare for EQuality
(resulting fields are either 0 or -1)
*/
#define pcmpeqd_m2r(var, reg) mmx_m2r(pcmpeqd, var, reg)
#define pcmpeqd_r2r(regs, regd) mmx_r2r(pcmpeqd, regs, regd)
#define pcmpeqd(vars, vard) mmx_m2m(pcmpeqd, vars, vard)
#define pcmpeqw_m2r(var, reg) mmx_m2r(pcmpeqw, var, reg)
#define pcmpeqw_r2r(regs, regd) mmx_r2r(pcmpeqw, regs, regd)
#define pcmpeqw(vars, vard) mmx_m2m(pcmpeqw, vars, vard)
#define pcmpeqb_m2r(var, reg) mmx_m2r(pcmpeqb, var, reg)
#define pcmpeqb_r2r(regs, regd) mmx_r2r(pcmpeqb, regs, regd)
#define pcmpeqb(vars, vard) mmx_m2m(pcmpeqb, vars, vard)
/* 2x32, 4x16, and 8x8 Parallel CoMPare for Greater Than
(resulting fields are either 0 or -1)
*/
#define pcmpgtd_m2r(var, reg) mmx_m2r(pcmpgtd, var, reg)
#define pcmpgtd_r2r(regs, regd) mmx_r2r(pcmpgtd, regs, regd)
#define pcmpgtd(vars, vard) mmx_m2m(pcmpgtd, vars, vard)
#define pcmpgtw_m2r(var, reg) mmx_m2r(pcmpgtw, var, reg)
#define pcmpgtw_r2r(regs, regd) mmx_r2r(pcmpgtw, regs, regd)
#define pcmpgtw(vars, vard) mmx_m2m(pcmpgtw, vars, vard)
#define pcmpgtb_m2r(var, reg) mmx_m2r(pcmpgtb, var, reg)
#define pcmpgtb_r2r(regs, regd) mmx_r2r(pcmpgtb, regs, regd)
#define pcmpgtb(vars, vard) mmx_m2m(pcmpgtb, vars, vard)
/* 1x64, 2x32, and 4x16 Parallel Shift Left Logical
*/
#define psllq_i2r(imm, reg) mmx_i2r(psllq, imm, reg)
#define psllq_m2r(var, reg) mmx_m2r(psllq, var, reg)
#define psllq_r2r(regs, regd) mmx_r2r(psllq, regs, regd)
#define psllq(vars, vard) mmx_m2m(psllq, vars, vard)
#define pslld_i2r(imm, reg) mmx_i2r(pslld, imm, reg)
#define pslld_m2r(var, reg) mmx_m2r(pslld, var, reg)
#define pslld_r2r(regs, regd) mmx_r2r(pslld, regs, regd)
#define pslld(vars, vard) mmx_m2m(pslld, vars, vard)
#define psllw_i2r(imm, reg) mmx_i2r(psllw, imm, reg)
#define psllw_m2r(var, reg) mmx_m2r(psllw, var, reg)
#define psllw_r2r(regs, regd) mmx_r2r(psllw, regs, regd)
#define psllw(vars, vard) mmx_m2m(psllw, vars, vard)
/* 1x64, 2x32, and 4x16 Parallel Shift Right Logical
*/
#define psrlq_i2r(imm, reg) mmx_i2r(psrlq, imm, reg)
#define psrlq_m2r(var, reg) mmx_m2r(psrlq, var, reg)
#define psrlq_r2r(regs, regd) mmx_r2r(psrlq, regs, regd)
#define psrlq(vars, vard) mmx_m2m(psrlq, vars, vard)
#define psrld_i2r(imm, reg) mmx_i2r(psrld, imm, reg)
#define psrld_m2r(var, reg) mmx_m2r(psrld, var, reg)
#define psrld_r2r(regs, regd) mmx_r2r(psrld, regs, regd)
#define psrld(vars, vard) mmx_m2m(psrld, vars, vard)
#define psrlw_i2r(imm, reg) mmx_i2r(psrlw, imm, reg)
#define psrlw_m2r(var, reg) mmx_m2r(psrlw, var, reg)
#define psrlw_r2r(regs, regd) mmx_r2r(psrlw, regs, regd)
#define psrlw(vars, vard) mmx_m2m(psrlw, vars, vard)
/* 2x32 and 4x16 Parallel Shift Right Arithmetic
*/
#define psrad_i2r(imm, reg) mmx_i2r(psrad, imm, reg)
#define psrad_m2r(var, reg) mmx_m2r(psrad, var, reg)
#define psrad_r2r(regs, regd) mmx_r2r(psrad, regs, regd)
#define psrad(vars, vard) mmx_m2m(psrad, vars, vard)
#define psraw_i2r(imm, reg) mmx_i2r(psraw, imm, reg)
#define psraw_m2r(var, reg) mmx_m2r(psraw, var, reg)
#define psraw_r2r(regs, regd) mmx_r2r(psraw, regs, regd)
#define psraw(vars, vard) mmx_m2m(psraw, vars, vard)
/* 2x32->4x16 and 4x16->8x8 PACK and Signed Saturate
(packs source and dest fields into dest in that order)
*/
#define packssdw_m2r(var, reg) mmx_m2r(packssdw, var, reg)
#define packssdw_r2r(regs, regd) mmx_r2r(packssdw, regs, regd)
#define packssdw(vars, vard) mmx_m2m(packssdw, vars, vard)
#define packsswb_m2r(var, reg) mmx_m2r(packsswb, var, reg)
#define packsswb_r2r(regs, regd) mmx_r2r(packsswb, regs, regd)
#define packsswb(vars, vard) mmx_m2m(packsswb, vars, vard)
/* 4x16->8x8 PACK and Unsigned Saturate
(packs source and dest fields into dest in that order)
*/
#define packuswb_m2r(var, reg) mmx_m2r(packuswb, var, reg)
#define packuswb_r2r(regs, regd) mmx_r2r(packuswb, regs, regd)
#define packuswb(vars, vard) mmx_m2m(packuswb, vars, vard)
/* 2x32->1x64, 4x16->2x32, and 8x8->4x16 UNPaCK Low
(interleaves low half of dest with low half of source
as padding in each result field)
*/
#define punpckldq_m2r(var, reg) mmx_m2r(punpckldq, var, reg)
#define punpckldq_r2r(regs, regd) mmx_r2r(punpckldq, regs, regd)
#define punpckldq(vars, vard) mmx_m2m(punpckldq, vars, vard)
#define punpcklwd_m2r(var, reg) mmx_m2r(punpcklwd, var, reg)
#define punpcklwd_r2r(regs, regd) mmx_r2r(punpcklwd, regs, regd)
#define punpcklwd(vars, vard) mmx_m2m(punpcklwd, vars, vard)
#define punpcklbw_m2r(var, reg) mmx_m2r(punpcklbw, var, reg)
#define punpcklbw_r2r(regs, regd) mmx_r2r(punpcklbw, regs, regd)
#define punpcklbw(vars, vard) mmx_m2m(punpcklbw, vars, vard)
/* 2x32->1x64, 4x16->2x32, and 8x8->4x16 UNPaCK High
(interleaves high half of dest with high half of source
as padding in each result field)
*/
#define punpckhdq_m2r(var, reg) mmx_m2r(punpckhdq, var, reg)
#define punpckhdq_r2r(regs, regd) mmx_r2r(punpckhdq, regs, regd)
#define punpckhdq(vars, vard) mmx_m2m(punpckhdq, vars, vard)
#define punpckhwd_m2r(var, reg) mmx_m2r(punpckhwd, var, reg)
#define punpckhwd_r2r(regs, regd) mmx_r2r(punpckhwd, regs, regd)
#define punpckhwd(vars, vard) mmx_m2m(punpckhwd, vars, vard)
#define punpckhbw_m2r(var, reg) mmx_m2r(punpckhbw, var, reg)
#define punpckhbw_r2r(regs, regd) mmx_r2r(punpckhbw, regs, regd)
#define punpckhbw(vars, vard) mmx_m2m(punpckhbw, vars, vard)
#define MOVE_8DWORDS_MMX(src,dst) \
__asm__ ( \
"movq (%1), %%mm0 \n" \
"movq 0x8(%1), %%mm1 \n" \
"movq 0x10(%1), %%mm2 \n" \
"movq 0x18(%1), %%mm3 \n" \
"movq %%mm0, (%0) \n" \
"movq %%mm1, 0x8(%0) \n" \
"movq %%mm2, 0x10(%0) \n" \
"movq %%mm3, 0x18(%0) \n" \
: \
: "q" (dst), "r" (src) \
: "memory", "st");
#define MOVE_10DWORDS_MMX(src,dst) \
__asm__ ( \
"movq (%1), %%mm0 \n" \
"movq 0x8(%1), %%mm1 \n" \
"movq 0x10(%1), %%mm2 \n" \
"movq 0x18(%1), %%mm3 \n" \
"movq 0x20(%1), %%mm4 \n" \
"movq %%mm0, (%0) \n" \
"movq %%mm1, 0x8(%0) \n" \
"movq %%mm2, 0x10(%0) \n" \
"movq %%mm3, 0x18(%0) \n" \
"movq %%mm4, 0x20(%0) \n" \
: \
: "q" (dst), "r" (src) \
: "memory", "st");
#define MOVE_16DWORDS_MMX(src,dst) \
__asm__ ( \
"movq (%1), %%mm0 \n" \
"movq 0x8(%1), %%mm1 \n" \
"movq 0x10(%1), %%mm2 \n" \
"movq 0x18(%1), %%mm3 \n" \
"movq 0x20(%1), %%mm4 \n" \
"movq 0x28(%1), %%mm5 \n" \
"movq 0x30(%1), %%mm6 \n" \
"movq 0x38(%1), %%mm7 \n" \
"movq %%mm0, (%0) \n" \
"movq %%mm1, 0x8(%0) \n" \
"movq %%mm2, 0x10(%0) \n" \
"movq %%mm3, 0x18(%0) \n" \
"movq %%mm4, 0x20(%0) \n" \
"movq %%mm5, 0x28(%0) \n" \
"movq %%mm6, 0x30(%0) \n" \
"movq %%mm7, 0x38(%0) \n" \
: \
: "q" (dst), "r" (src) \
: "memory", "st");
#define MOVE_16DWORDS_MMX2(src,dst) \
__asm__ ( \
"movq (%1), %%mm0 \n" \
"movq 0x8(%1), %%mm1 \n" \
"movq 0x10(%1), %%mm2 \n" \
"movq 0x18(%1), %%mm3 \n" \
"movq 0x20(%1), %%mm4 \n" \
"movq 0x28(%1), %%mm5 \n" \
"movq 0x30(%1), %%mm6 \n" \
"movq 0x38(%1), %%mm7 \n" \
"movntq %%mm0, (%0) \n" \
"movntq %%mm1, 0x8(%0) \n" \
"movntq %%mm2, 0x10(%0) \n" \
"movntq %%mm3, 0x18(%0) \n" \
"movntq %%mm4, 0x20(%0) \n" \
"movntq %%mm5, 0x28(%0) \n" \
"movntq %%mm6, 0x30(%0) \n" \
"movntq %%mm7, 0x38(%0) \n" \
: \
: "q" (dst), "r" (src) \
: "memory", "st");
/* Empty MMx State
(used to clean-up when going from mmx to float use
of the registers that are shared by both; note that
there is no float-to-mmx operation needed, because
only the float tag word info is corruptible)
*/
#define emms() __asm__ __volatile__ ("emms":::"memory")
#define sfence() __asm__ __volatile__ ("sfence":::"memory")
/* additions to detect mmx - */
/* Raster <raster@rasterman.com> */
#define CPUID_MMX (1 << 23) /* flags: mmx */
#define CPUID_SSE (1 << 25) /* flags: xmm */
#define CPUID_SSE2 (1 << 26) /* flags: ? */
#ifdef __amd64
#define have_cpuid(cpuid_ret) \
__asm__ __volatile__ ( \
".align 32 \n" \
" pushq %%rbx \n" \
" pushfq \n" \
" popq %%rax \n" \
" movq %%rax, %%rbx \n" \
" xorq $0x200000, %%rax \n" \
" pushq %%rax \n" \
" popfq \n" \
" pushfq \n" \
" popq %%rax \n" \
" cmpq %%rax, %%rbx \n" \
" je 1f \n" \
" movl $1, %0 \n" \
" jmp 2f \n" \
"1: \n" \
" movl $0, %0 \n" \
"2: \n" \
" popq %%rbx \n" \
: "=m" (cpuid_ret) \
);
#define get_cpuid(cpuid_ret) \
__asm__ __volatile__ ( \
".align 32 \n" \
" pushq %%rax \n" \
" movl $1, %%eax \n" \
" cpuid \n" \
" test $0x00800000, %%edx\n" \
"1: \n" \
" movl %%edx, %0 \n" \
" jmp 2f \n" \
"2: \n" \
" movl $0, %0 \n" \
" popq %%rax \n" \
: "=m" (cpuid_ret) \
);
#else
#define have_cpuid(cpuid_ret) \
__asm__ __volatile__ ( \
".align 32 \n" \
" pushl %%ebx \n" \
" pushfl \n" \
" popl %%eax \n" \
" movl %%eax, %%ebx \n" \
" xorl $0x200000, %%eax \n" \
" pushl %%eax \n" \
" popfl \n" \
" pushfl \n" \
" popl %%eax \n" \
" cmpl %%eax, %%ebx \n" \
" je 1f \n" \
" movl $1, %0 \n" \
" jmp 2f \n" \
"1: \n" \
" movl $0, %0 \n" \
"2: \n" \
" popl %%ebx \n" \
: "=m" (cpuid_ret) \
);
#define get_cpuid(cpuid_ret) \
__asm__ __volatile__ ( \
".align 32 \n" \
" pushl %%eax \n" \
" movl $1, %%eax \n" \
" cpuid \n" \
" test $0x00800000, %%edx\n" \
"1: \n" \
" movl %%edx, %0 \n" \
" jmp 2f \n" \
"2: \n" \
" movl $0, %0 \n" \
" popl %%eax \n" \
: "=m" (cpuid_ret) \
);
#endif
/* P3 instructions - need to figure how to detect? */
#define prefetch(var) \
__asm__ __volatile__ ( \
"prefetchnta (%0) \n" \
: \
: "r" (var) \
);
#define prefetch0(var) \
__asm__ __volatile__ ( \
"prefetcht0 (%0) \n" \
: \
: "r" (var) \
);
#define prefetch1(var) \
__asm__ __volatile__ ( \
"prefetcht1 (%0) \n" \
: \
: "r" (var) \
);
#define prefetch2(var) \
__asm__ __volatile__ ( \
"prefetcht2 (%0) \n" \
: \
: "r" (var) \
);
#define pshufw(r1, r2, imm) \
__asm__ __volatile__ ( \
"pshufw $" #imm ", %" #r1 ", %" #r2 " \n" \
);
/* end additions */
#endif

@ -1,6 +1,11 @@
#include "e.h"
#include "e_mod_main.h"
/* i measure a mere 9% speedup using mmx for simd sums. :(
* need to detect mmx capbale cpu's to enable this though
#define MMX 1
*/
/* TODO List:
*
* * bug in shadow_x < 0 and shadow_y < 0 needs to be fixed (not urgent though)
@ -99,6 +104,23 @@ e_modapi_init(E_Module *m)
}
ds = _ds_init(m);
m->config_menu = _ds_config_menu_new(ds);
/*
{
Shpix *sh;
double t1, t2;
int i;
sh = _ds_shpix_new(1000, 1000);
t1 = ecore_time_get();
for (i = 0; i < 100; i++)
{
_ds_shpix_blur(sh, 0, 0, 1000, 100, ds->table.gauss, ds->conf->blur_size);
}
t2 = ecore_time_get();
printf("blur time: %3.3f\n", t2 -t1);
_ds_shpix_free(sh);
}
*/
return ds;
}
@ -1470,12 +1492,36 @@ _ds_gauss_blur_h(unsigned char *pix, unsigned char *pix_dst, int pix_w, int pix_
for (y = ry; y < ryy; y++)
{
p1 = pp;
#ifdef MMX
/* sum 4 pixels at once */
pxor_r2r(mm7, mm7); // mm7 = 00000000
pxor_r2r(mm2, mm2); // mm2 = 00000000
for (l = 0; l <= (l2 - 3); l += 4)
{
movd_m2r(((int *)p1)[0], mm0); // mm0 = 0000abcd
movd_m2r(((int *)(&lut[l]))[0], mm1); // mm1 = 0000wxyz
punpcklbw_r2r(mm2, mm0); // mm0 = 0a0b0c0d
punpcklbw_r2r(mm2, mm1); // mm1 = 0w0x0y0z
pmaddwd_r2r(mm0, mm1); // mm1 = (a * w) + (b * x) | (c * y) + (d * z)
paddd_r2r(mm1, mm7); // mm7 += (c * y) + (d * z)
psrlq_i2r(32, mm1); // mm0 = 0000 | (a * w) + (b * x)
paddd_r2r(mm1, mm7); // mm7 += (a * w) + (b * x)
p1 += 4;
}
movd_r2m(mm7, sum); // sum = mm7
for (; l <= l2; l++)
{
sum += (int)(*p1) * (int)lut[l];
p1++;
}
#else
sum = 0;
for (l = 0; l <= l2; l++)
{
sum += (int)(*p1) * (int)lut[l];
p1++;
}
#endif
*p2 = sum / full;
p2 += pix_w;
pp += pix_w;
@ -1501,13 +1547,16 @@ _ds_gauss_blur_h(unsigned char *pix, unsigned char *pix_dst, int pix_w, int pix_
}
}
}
#ifdef MMX
emms();
#endif
}
static void
_ds_gauss_blur_v(unsigned char *pix, unsigned char *pix_dst, int pix_w, int pix_h, unsigned char *lut, int blur, int rx, int ry, int rxx, int ryy)
{
int x, y;
int i, sum, weight, l, l1, l2, wt, y1, y2;
int i, sum, weight, l, l1, l2, wt, y1, y2, tpix;
unsigned char *p1, *p2, *pp;
int full, usefull;
@ -1542,12 +1591,39 @@ _ds_gauss_blur_v(unsigned char *pix, unsigned char *pix_dst, int pix_w, int pix_
for (x = rx; x < rxx; x++)
{
p1 = pp;
#ifdef MMX
/* sum 4 pixels at once */
pxor_r2r(mm7, mm7); // mm7 = 00000000
pxor_r2r(mm2, mm2); // mm2 = 00000000
for (l = 0; l <= (l2 - 3); l += 4)
{
tpix = (p1[0]); p1 += pix_w;
tpix |= (p1[0] << 8); p1 += pix_w;
tpix |= (p1[0] << 16); p1 += pix_w;
tpix |= (p1[0] << 24); p1 += pix_w;
movd_m2r(tpix, mm0); // mm0 = 0000abcd
movd_m2r(((int *)(&lut[l]))[0], mm1); // mm1 = 0000wxyz
punpcklbw_r2r(mm2, mm0); // mm0 = 0a0b0c0d
punpcklbw_r2r(mm2, mm1); // mm1 = 0w0x0y0z
pmaddwd_r2r(mm0, mm1); // mm1 = (a * w) + (b * x) | (c * y) + (d * z)
paddd_r2r(mm1, mm7); // mm7 += (c * y) + (d * z)
psrlq_i2r(32, mm1); // mm0 = 0000 | (a * w) + (b * x)
paddd_r2r(mm1, mm7); // mm7 += (a * w) + (b * x)
}
movd_r2m(mm7, sum); // sum = mm7
for (; l <= l2; l++)
{
sum += (int)(*p1) * (int)lut[l];
p1 += pix_w;
}
#else
sum = 0;
for (l = 0; l <= l2; l++)
{
sum += (int)(*p1) * (int)lut[l];
p1 += pix_w;
}
#endif
*p2 = sum / full;
p2++;
pp++;
@ -1573,6 +1649,9 @@ _ds_gauss_blur_v(unsigned char *pix, unsigned char *pix_dst, int pix_w, int pix_
}
}
}
#ifdef MMX
emms();
#endif
}
static Shpix *
@ -1765,7 +1844,7 @@ _ds_shpix_object_set(Shpix *sp, Evas_Object *o, int x, int y, int w, int h)
{
unsigned char *p;
unsigned int *pix2, *p2;
int xx, yy, jump;
int xx, yy, jump, pix;
if (!sp) return;
if (!o) return;
@ -1799,17 +1878,43 @@ _ds_shpix_object_set(Shpix *sp, Evas_Object *o, int x, int y, int w, int h)
p2 = pix2;
for (yy = 0; yy < h; yy++)
{
#ifdef MMX
/* expand 2 pixels at once */
for (xx = 0; xx < (w - 1); xx += 2)
{
pix = (p[1] << 24) | (p[0] << 8);
movd_m2r(pix, mm1); // mm1 = A0a0
pxor_r2r(mm0, mm0); // mm0 = 00000000
punpcklbw_r2r(mm1, mm0); // mm0 = A000a000
movq_r2m(mm0, p2[0]); // *p2 = mm0;
p2 += 2;
p += 2;
}
for (; xx < w; xx++)
{
*p2 = ((*p) << 24);
p2++;
p++;
}
#else
for (xx = 0; xx < w; xx++)
{
*p2 = ((*p) << 24);
p2++;
p++;
}
#endif
p += jump;
}
evas_object_image_data_set(o, pix2);
evas_object_image_data_update_add(o, 0, 0, w, h);
}
#ifdef MMX
/* we did mmx stuff - cleanup */
emms();
#else
#endif
}
static void

Loading…
Cancel
Save