Remove PPC perf counter support

This functionality is better accessed through tools like oprofile. Originally committed as revision 23808 to svn://svn.ffmpeg.org/ffmpeg/trunk

Måns Rullgård committed 16 years ago

Commit 2829ce41 parent a78819613 files · +0 −513Browse files

Unified · Split

13 files

configure +0 −4
doc/ffmpeg_powerpc_performance_evaluation_howto.txt +0 −172
ffmpeg.c +0 −5
libavcodec/ppc/dsputil_altivec.c +0 −42
libavcodec/ppc/dsputil_ppc.c +0 −79
libavcodec/ppc/dsputil_ppc.h +0 −154
libavcodec/ppc/fdct_altivec.c +0 −7
libavcodec/ppc/fft_altivec.c +0 −6
libavcodec/ppc/gmc_altivec.c +0 −8
libavcodec/ppc/h264_altivec.c +0 −1
libavcodec/ppc/h264_template_altivec.c +0 −16
libavcodec/ppc/idct_altivec.c +0 −14
libavcodec/ppc/mpegvideo_altivec.c +0 −5

configure+0−4

   --arch=ARCH              select architecture [$arch]
   --cpu=CPU                select the minimum required CPU (affects
                            instruction selection, may crash on older CPUs)
-  --enable-powerpc-perf    enable performance report on PPC
-                           (requires enabling PMC)
   --disable-asm            disable all assembler optimizations
   --disable-altivec        disable AltiVec optimizations
   --disable-amd3dnow       disable 3DNow! optimizations
     nonfree
     pic
     postproc
-    powerpc_perf
     rdft
     runtime_cpudetect
     shared
     echo "AltiVec enabled           ${altivec-no}"
     echo "PPC 4xx optimizations     ${ppc4xx-no}"
     echo "dcbzl available           ${dcbzl-no}"
-    echo "performance report        ${powerpc_perf-no}"
 fi
 if enabled sparc; then
     echo "VIS enabled               ${vis-no}"

doc/ffmpeg_powerpc_performance_evaluation_howto.txt+0−172

@@ -1,172 +0,0 @@
1	FFmpeg & evaluating performance on the PowerPC Architecture HOWTO
2
3	(c) 2003-2004 Romain Dolbeau <romain@dolbeau.org>
4
5
6
7	I - Introduction
8
9	The PowerPC architecture and its SIMD extension AltiVec offer some
10	interesting tools to evaluate performance and improve the code.
11	This document tries to explain how to use those tools with FFmpeg.
12
13	The architecture itself offers two ways to evaluate the performance of
14	a given piece of code:
15
16	1) The Time Base Registers (TBL)
17	2) The Performance Monitor Counter Registers (PMC)
18
19	The first ones are always available, always active, but they're not very
20	accurate: the registers increment by one every four bus cycles. On
21	my 667 Mhz tiBook (ppc7450), this means once every twenty processor
22	cycles. So we won't use that.
23
24	The PMC are much more useful: not only can they report cycle-accurate
25	timing, but they can also be used to monitor many other parameters,
26	such as the number of AltiVec stalls for every kind of instruction,
27	or instruction cache misses. The downside is that not all processors
28	support the PMC (all G3, all G4 and the 970 do support them), and
29	they're inactive by default - you need to activate them with a
30	dedicated tool. Also, the number of available PMC depends on the
31	procesor: the various 604 have 2, the various 75x (aka. G3) have 4,
32	and the various 74xx (aka G4) have 6.
33
34	WARNING: The PowerPC 970 is not very well documented, and its PMC
35	registers are 64 bits wide. To properly notify the code, you must
36	tune for the 970 (using --tune=970), or the code will assume 32 bit
37	registers.
38
39
40	II - Enabling FFmpeg PowerPC performance support
41
42	This needs to be done by hand. First, you need to configure FFmpeg as
43	usual, but add the "--powerpc-perf-enable" option. For instance:
44
45	#####
46	./configure --prefix=/usr/local/ffmpeg-svn --cc=gcc-3.3 --tune=7450 --powerpc-perf-enable
47	#####
48
49	This will configure FFmpeg to install inside /usr/local/ffmpeg-svn,
50	compiling with gcc-3.3 (you should try to use this one or a newer
51	gcc), and tuning for the PowerPC 7450 (i.e. the newer G4; as a rule of
52	thumb, those at 550Mhz and more). It will also enable the PMC.
53
54	You may also edit the file "config.h" to enable the following line:
55
56	#####
57	// #define ALTIVEC_USE_REFERENCE_C_CODE 1
58	#####
59
60	If you enable this line, then the code will not make use of AltiVec,
61	but will use the reference C code instead. This is useful to compare
62	performance between two versions of the code.
63
64	Also, the number of enabled PMC is defined in "libavcodec/ppc/dsputil_ppc.h":
65
66	#####
67	#define POWERPC_NUM_PMC_ENABLED 4
68	#####
69
70	If you have a G4 CPU, you can enable all 6 PMC. DO NOT enable more
71	PMC than available on your CPU!
72
73	Then, simply compile FFmpeg as usual (make && make install).
74
75
76
77	III - Using FFmpeg PowerPC performance support
78
79	This FFmeg can be used exactly as usual. But before exiting, FFmpeg
80	will dump a per-function report that looks like this:
81
82	#####
83	PowerPC performance report
84	Values are from the PMC registers, and represent whatever the
85	registers are set to record.
86	Function "gmc1_altivec" (pmc1):
87	min: 231
88	max: 1339867
89	avg: 558.25 (255302)
90	Function "gmc1_altivec" (pmc2):
91	min: 93
92	max: 2164
93	avg: 267.31 (255302)
94	Function "gmc1_altivec" (pmc3):
95	min: 72
96	max: 1987
97	avg: 276.20 (255302)
98	(...)
99	#####
100
101	In this example, PMC1 was set to record CPU cycles, PMC2 was set to
102	record AltiVec Permute Stall Cycles, and PMC3 was set to record AltiVec
103	Issue Stalls.
104
105	The function "gmc1_altivec" was monitored 255302 times, and the
106	minimum execution time was 231 processor cycles. The max and average
107	aren't much use, as it's very likely the OS interrupted execution for
108	reasons of its own :-(
109
110	With the exact same settings and source file, but using the reference C
111	code we get:
112
113	#####
114	PowerPC performance report
115	Values are from the PMC registers, and represent whatever the
116	registers are set to record.
117	Function "gmc1_altivec" (pmc1):
118	min: 592
119	max: 2532235
120	avg: 962.88 (255302)
121	Function "gmc1_altivec" (pmc2):
122	min: 0
123	max: 33
124	avg: 0.00 (255302)
125	Function "gmc1_altivec" (pmc3):
126	min: 0
127	max: 350
128	avg: 0.03 (255302)
129	(...)
130	#####
131
132	592 cycles, so the fastest AltiVec execution is about 2.5x faster than
133	the fastest C execution in this example. It's not perfect but it's not
134	bad (well I wrote this function so I can't say otherwise :-).
135
136	Once you have that kind of report, you can try to improve things by
137	finding what goes wrong and fixing it; in the example above, one
138	should try to diminish the number of AltiVec stalls, as this may
139	improve performance.
140
141
142
143	IV) Enabling the PMC in Mac OS X
144
145	This is easy. Use "Monster" and "monster". Those tools come from
146	Apple's CHUD package, and can be found hidden in the developer web
147	site & FTP site. "MONster" is the graphical application, use it to
148	generate a config file specifying what each register should
149	monitor. Then use the command-line application "monster" to use that
150	config file, and enjoy the results.
151
152	Note that "MONster" can be used for many other things, but it's
153	documented by Apple, it's not my subject.
154
155	If you are using CHUD 4.4.2 or later, you'll notice that MONster is
156	no longer available. It's been superseeded by Shark, where
157	configuration of PMCs is available as a plugin.
158
159
160
161	V) Enabling the PMC on Linux
162
163	On linux you may use oprofile from http://oprofile.sf.net, depending on the
164	version and the cpu you may need to apply a patch[1] to access a set of the
165	possibile counters from the userspace application. You can always define them
166	using the kernel interface /dev/oprofile/* .
167
168	[1] http://dev.gentoo.org/~lu_zero/development/oprofile-g4-20060423.patch
169
170	--
171	Romain Dolbeau <romain@dolbeau.org>
172	Luca Barbato <lu_zero@gentoo.org>

ffmpeg.c+0−5

     av_free(video_standard);
-#if CONFIG_POWERPC_PERF
-    void powerpc_display_perf_report(void);
-    powerpc_display_perf_report();
-#endif /* CONFIG_POWERPC_PERF */
     for (i=0;i<AVMEDIA_TYPE_NB;i++)
         av_free(avcodec_opts[i]);
     av_free(avformat_opts);

libavcodec/ppc/dsputil_altivec.c+0−42

 #include <altivec.h>
 #endif
 #include "libavcodec/dsputil.h"
-#include "dsputil_ppc.h"
 #include "util_altivec.h"
 #include "types_altivec.h"
 #include "dsputil_altivec.h"
 /* next one assumes that ((line_size % 16) == 0) */
 void put_pixels16_altivec(uint8_t *block, const uint8_t *pixels, int line_size, int h)
 {
-POWERPC_PERF_DECLARE(altivec_put_pixels16_num, 1);
     register vector unsigned char pixelsv1, pixelsv2;
     register vector unsigned char pixelsv1B, pixelsv2B;
     register vector unsigned char pixelsv1C, pixelsv2C;
     register int line_size_3 = line_size + line_size_2;
     register int line_size_4 = line_size << 2;
-POWERPC_PERF_START_COUNT(altivec_put_pixels16_num, 1);
 // hand-unrolling the loop by 4 gains about 15%
 // mininum execution time goes from 74 to 60 cycles
 // it's faster than -funroll-loops, but using
         block +=line_size_4;
     }
 #endif
-POWERPC_PERF_STOP_COUNT(altivec_put_pixels16_num, 1);
 }
 /* next one assumes that ((line_size % 16) == 0) */
 #define op_avg(a,b)  a = ( ((a)|(b)) - ((((a)^(b))&0xFEFEFEFEUL)>>1) )
 void avg_pixels16_altivec(uint8_t *block, const uint8_t *pixels, int line_size, int h)
 {
-POWERPC_PERF_DECLARE(altivec_avg_pixels16_num, 1);
     register vector unsigned char pixelsv1, pixelsv2, pixelsv, blockv;
     register vector unsigned char perm = vec_lvsl(0, pixels);
     int i;
-POWERPC_PERF_START_COUNT(altivec_avg_pixels16_num, 1);
     for (i = 0; i < h; i++) {
         pixelsv1 = vec_ld( 0, pixels);
         pixelsv2 = vec_ld(16,pixels);
         pixels+=line_size;
         block +=line_size;
     }
-POWERPC_PERF_STOP_COUNT(altivec_avg_pixels16_num, 1);
 }
 /* next one assumes that ((line_size % 8) == 0) */
 static void avg_pixels8_altivec(uint8_t * block, const uint8_t * pixels, int line_size, int h)
 {
-POWERPC_PERF_DECLARE(altivec_avg_pixels8_num, 1);
     register vector unsigned char pixelsv1, pixelsv2, pixelsv, blockv;
     int i;
-POWERPC_PERF_START_COUNT(altivec_avg_pixels8_num, 1);
    for (i = 0; i < h; i++) {
        /* block is 8 bytes-aligned, so we're either in the
           left block (16 bytes-aligned) or in the right block (not) */
        pixels += line_size;
        block += line_size;
    }
-POWERPC_PERF_STOP_COUNT(altivec_avg_pixels8_num, 1);
 }
 /* next one assumes that ((line_size % 8) == 0) */
 static void put_pixels8_xy2_altivec(uint8_t *block, const uint8_t *pixels, int line_size, int h)
 {
-POWERPC_PERF_DECLARE(altivec_put_pixels8_xy2_num, 1);
     register int i;
     register vector unsigned char pixelsv1, pixelsv2, pixelsavg;
     register vector unsigned char blockv, temp1, temp2;
                          (vector unsigned short)pixelsv2);
     pixelssum1 = vec_add(pixelssum1, vctwo);
-POWERPC_PERF_START_COUNT(altivec_put_pixels8_xy2_num, 1);
     for (i = 0; i < h ; i++) {
         int rightside = ((unsigned long)block & 0x0000000F);
         blockv = vec_ld(0, block);
         block += line_size;
         pixels += line_size;
     }
-POWERPC_PERF_STOP_COUNT(altivec_put_pixels8_xy2_num, 1);
 }
 /* next one assumes that ((line_size % 8) == 0) */
 static void put_no_rnd_pixels8_xy2_altivec(uint8_t *block, const uint8_t *pixels, int line_size, int h)
 {
-POWERPC_PERF_DECLARE(altivec_put_no_rnd_pixels8_xy2_num, 1);
     register int i;
     register vector unsigned char pixelsv1, pixelsv2, pixelsavg;
     register vector unsigned char blockv, temp1, temp2;
                          (vector unsigned short)pixelsv2);
     pixelssum1 = vec_add(pixelssum1, vcone);
-POWERPC_PERF_START_COUNT(altivec_put_no_rnd_pixels8_xy2_num, 1);
     for (i = 0; i < h ; i++) {
         int rightside = ((unsigned long)block & 0x0000000F);
         blockv = vec_ld(0, block);
         block += line_size;
         pixels += line_size;
     }
-POWERPC_PERF_STOP_COUNT(altivec_put_no_rnd_pixels8_xy2_num, 1);
 }
 /* next one assumes that ((line_size % 16) == 0) */
 static void put_pixels16_xy2_altivec(uint8_t * block, const uint8_t * pixels, int line_size, int h)
 {
-POWERPC_PERF_DECLARE(altivec_put_pixels16_xy2_num, 1);
     register int i;
     register vector unsigned char pixelsv1, pixelsv2, pixelsv3, pixelsv4;
     register vector unsigned char blockv, temp1, temp2;
     register const vector unsigned char vczero = (const vector unsigned char)vec_splat_u8(0);
     register const vector unsigned short vctwo = (const vector unsigned short)vec_splat_u16(2);
-POWERPC_PERF_START_COUNT(altivec_put_pixels16_xy2_num, 1);
     temp1 = vec_ld(0, pixels);
     temp2 = vec_ld(16, pixels);
     pixelsv1 = vec_perm(temp1, temp2, vec_lvsl(0, pixels));
         block += line_size;
         pixels += line_size;
     }
-POWERPC_PERF_STOP_COUNT(altivec_put_pixels16_xy2_num, 1);
 }
 /* next one assumes that ((line_size % 16) == 0) */
 static void put_no_rnd_pixels16_xy2_altivec(uint8_t * block, const uint8_t * pixels, int line_size, int h)
 {
-POWERPC_PERF_DECLARE(altivec_put_no_rnd_pixels16_xy2_num, 1);
     register int i;
     register vector unsigned char pixelsv1, pixelsv2, pixelsv3, pixelsv4;
     register vector unsigned char blockv, temp1, temp2;
     register const vector unsigned short vcone = (const vector unsigned short)vec_splat_u16(1);
     register const vector unsigned short vctwo = (const vector unsigned short)vec_splat_u16(2);
-POWERPC_PERF_START_COUNT(altivec_put_no_rnd_pixels16_xy2_num, 1);
     temp1 = vec_ld(0, pixels);
     temp2 = vec_ld(16, pixels);
     pixelsv1 = vec_perm(temp1, temp2, vec_lvsl(0, pixels));
         block += line_size;
         pixels += line_size;
     }
-POWERPC_PERF_STOP_COUNT(altivec_put_no_rnd_pixels16_xy2_num, 1);
 }
 static int hadamard8_diff8x8_altivec(/*MpegEncContext*/ void *s, uint8_t *dst, uint8_t *src, int stride, int h){
-POWERPC_PERF_DECLARE(altivec_hadamard8_diff8x8_num, 1);
     int sum;
     register const vector unsigned char vzero =
                             (const vector unsigned char)vec_splat_u8(0);
     register vector signed short temp0, temp1, temp2, temp3, temp4,
                                  temp5, temp6, temp7;
-POWERPC_PERF_START_COUNT(altivec_hadamard8_diff8x8_num, 1);
     {
     register const vector signed short vprod1 =(const vector signed short)
                                                { 1,-1, 1,-1, 1,-1, 1,-1 };
     vsum = vec_splat(vsum, 3);
     vec_ste(vsum, 0, &sum);
     }
-POWERPC_PERF_STOP_COUNT(altivec_hadamard8_diff8x8_num, 1);
     return sum;
 }
 }
 static int hadamard8_diff16_altivec(/*MpegEncContext*/ void *s, uint8_t *dst, uint8_t *src, int stride, int h){
-POWERPC_PERF_DECLARE(altivec_hadamard8_diff16_num, 1);
     int score;
-POWERPC_PERF_START_COUNT(altivec_hadamard8_diff16_num, 1);
     score = hadamard8_diff16x8_altivec(s, dst, src, stride, 8);
     if (h==16) {
         dst += 8*stride;
         src += 8*stride;
         score += hadamard8_diff16x8_altivec(s, dst, src, stride, 8);
     }
-POWERPC_PERF_STOP_COUNT(altivec_hadamard8_diff16_num, 1);
     return score;
 }
 /* next one assumes that ((line_size % 8) == 0) */
 static void avg_pixels8_xy2_altivec(uint8_t *block, const uint8_t *pixels, int line_size, int h)
 {
-POWERPC_PERF_DECLARE(altivec_avg_pixels8_xy2_num, 1);
     register int i;
     register vector unsigned char pixelsv1, pixelsv2, pixelsavg;
     register vector unsigned char blockv, temp1, temp2, blocktemp;
                          (vector unsigned short)pixelsv2);
     pixelssum1 = vec_add(pixelssum1, vctwo);
-POWERPC_PERF_START_COUNT(altivec_avg_pixels8_xy2_num, 1);
     for (i = 0; i < h ; i++) {
         int rightside = ((unsigned long)block & 0x0000000F);
         blockv = vec_ld(0, block);
         block += line_size;
         pixels += line_size;
     }
-POWERPC_PERF_STOP_COUNT(altivec_avg_pixels8_xy2_num, 1);
 }
 void dsputil_init_altivec(DSPContext* c, AVCodecContext *avctx)

libavcodec/ppc/dsputil_ppc.c+0−79

@@ -21,9 +21,6 @@ · 20 unmodified lines
21	*/	21	*/
22		22
23	#include "libavcodec/dsputil.h"	23	#include "libavcodec/dsputil.h"
24
25	#include "dsputil_ppc.h"
26
27	#include "dsputil_altivec.h"	24	#include "dsputil_altivec.h"
28		25
29	int mm_flags = 0;	26	int mm_flags = 0;
@@ -39,63 +36,6 @@ int mm_support(void) · 9 unmodified lines
39	return result;	36	return result;
40	}	37	}
41		38
42	#if CONFIG_POWERPC_PERF
43	unsigned long long perfdata[POWERPC_NUM_PMC_ENABLED][powerpc_perf_total][powerpc_data_total];
44	/* list below must match enum in dsputil_ppc.h */
45	static unsigned char* perfname[] = {
46	"ff_fft_calc_altivec",
47	"gmc1_altivec",
48	"dct_unquantize_h263_altivec",
49	"fdct_altivec",
50	"idct_add_altivec",
51	"idct_put_altivec",
52	"put_pixels16_altivec",
53	"avg_pixels16_altivec",
54	"avg_pixels8_altivec",
55	"put_pixels8_xy2_altivec",
56	"put_no_rnd_pixels8_xy2_altivec",
57	"put_pixels16_xy2_altivec",
58	"put_no_rnd_pixels16_xy2_altivec",
59	"hadamard8_diff8x8_altivec",
60	"hadamard8_diff16_altivec",
61	"avg_pixels8_xy2_altivec",
62	"clear_blocks_dcbz32_ppc",
63	"clear_blocks_dcbz128_ppc",
64	"put_h264_chroma_mc8_altivec",
65	"avg_h264_chroma_mc8_altivec",
66	"put_h264_qpel16_h_lowpass_altivec",
67	"avg_h264_qpel16_h_lowpass_altivec",
68	"put_h264_qpel16_v_lowpass_altivec",
69	"avg_h264_qpel16_v_lowpass_altivec",
70	"put_h264_qpel16_hv_lowpass_altivec",
71	"avg_h264_qpel16_hv_lowpass_altivec",
72	""
73	};
74	#include <stdio.h>
75	#endif
76
77	#if CONFIG_POWERPC_PERF
78	void powerpc_display_perf_report(void)
79	{
80	int i, j;
81	av_log(NULL, AV_LOG_INFO, "PowerPC performance report\n Values are from the PMC registers, and represent whatever the registers are set to record.\n");
82	for(i = 0 ; i < powerpc_perf_total ; i++) {
83	for (j = 0; j < POWERPC_NUM_PMC_ENABLED ; j++) {
84	if (perfdata[j][i][powerpc_data_num] != (unsigned long long)0)
85	av_log(NULL, AV_LOG_INFO,
86	" Function \"%s\" (pmc%d):\n\tmin: %"PRIu64"\n\tmax: %"PRIu64"\n\tavg: %1.2lf (%"PRIu64")\n",
87	perfname[i],
88	j+1,
89	perfdata[j][i][powerpc_data_min],
90	perfdata[j][i][powerpc_data_max],
91	(double)perfdata[j][i][powerpc_data_sum] /
92	(double)perfdata[j][i][powerpc_data_num],
93	perfdata[j][i][powerpc_data_num]);
94	}
95	}
96	}
97	#endif /* CONFIG_POWERPC_PERF */
98
99	/* *** WARNING * WARNING * WARNING *** */	39	/* *** WARNING * WARNING * WARNING *** */
100	/*	40	/*
101	clear_blocks_dcbz32_ppc will not work properly on PowerPC processors with a	41	clear_blocks_dcbz32_ppc will not work properly on PowerPC processors with a
@@ -118,10 +58,8 @@ and <http://developer.apple.com/technotes/tn/tn2086.html> · 16 unmodified lines
118	*/	58	*/
119	static void clear_blocks_dcbz32_ppc(DCTELEM *blocks)	59	static void clear_blocks_dcbz32_ppc(DCTELEM *blocks)
120	{	60	{
121	POWERPC_PERF_DECLARE(powerpc_clear_blocks_dcbz32, 1);
122	register int misal = ((unsigned long)blocks & 0x00000010);	61	register int misal = ((unsigned long)blocks & 0x00000010);
123	register int i = 0;	62	register int i = 0;
124	POWERPC_PERF_START_COUNT(powerpc_clear_blocks_dcbz32, 1);
125	#if 1	63	#if 1
126	if (misal) {	64	if (misal) {
127	((unsigned long*)blocks)[0] = 0L;	65	((unsigned long*)blocks)[0] = 0L;
@@ -143,7 +81,6 @@ POWERPC_PERF_START_COUNT(powerpc_clear_blocks_dcbz32, 1); · 15 unmodified lines
143	#else	81	#else
144	memset(blocks, 0, sizeof(DCTELEM)664);	82	memset(blocks, 0, sizeof(DCTELEM)664);
145	#endif	83	#endif
146	POWERPC_PERF_STOP_COUNT(powerpc_clear_blocks_dcbz32, 1);
147	}	84	}
148		85
149	/* same as above, when dcbzl clear a whole 128B cache line	86	/* same as above, when dcbzl clear a whole 128B cache line
@@ -151,10 +88,8 @@ POWERPC_PERF_STOP_COUNT(powerpc_clear_blocks_dcbz32, 1); · 1 unmodified line
151	#if HAVE_DCBZL	88	#if HAVE_DCBZL
152	static void clear_blocks_dcbz128_ppc(DCTELEM *blocks)	89	static void clear_blocks_dcbz128_ppc(DCTELEM *blocks)
153	{	90	{
154	POWERPC_PERF_DECLARE(powerpc_clear_blocks_dcbz128, 1);
155	register int misal = ((unsigned long)blocks & 0x0000007f);	91	register int misal = ((unsigned long)blocks & 0x0000007f);
156	register int i = 0;	92	register int i = 0;
157	POWERPC_PERF_START_COUNT(powerpc_clear_blocks_dcbz128, 1);
158	#if 1	93	#if 1
159	if (misal) {	94	if (misal) {
160	// we could probably also optimize this case,	95	// we could probably also optimize this case,
@@ -169,7 +104,6 @@ POWERPC_PERF_START_COUNT(powerpc_clear_blocks_dcbz128, 1); · 8 unmodified lines
169	#else	104	#else
170	memset(blocks, 0, sizeof(DCTELEM)664);	105	memset(blocks, 0, sizeof(DCTELEM)664);
171	#endif	106	#endif
172	POWERPC_PERF_STOP_COUNT(powerpc_clear_blocks_dcbz128, 1);
173	}	107	}
174	#else	108	#else
175	static void clear_blocks_dcbz128_ppc(DCTELEM *blocks)	109	static void clear_blocks_dcbz128_ppc(DCTELEM *blocks)
@@ -279,19 +213,6 @@ void dsputil_init_ppc(DSPContext* c, AVCodecContext *avctx) · 103 unmodified lines
279	}	213	}
280	}	214	}
281		215
282	#if CONFIG_POWERPC_PERF
283	{
284	int i, j;
285	for (i = 0 ; i < powerpc_perf_total ; i++) {
286	for (j = 0; j < POWERPC_NUM_PMC_ENABLED ; j++) {
287	perfdata[j][i][powerpc_data_min] = 0xFFFFFFFFFFFFFFFFULL;
288	perfdata[j][i][powerpc_data_max] = 0x0000000000000000ULL;
289	perfdata[j][i][powerpc_data_sum] = 0x0000000000000000ULL;
290	perfdata[j][i][powerpc_data_num] = 0x0000000000000000ULL;
291	}
292	}
293	}
294	#endif /* CONFIG_POWERPC_PERF */
295	}	216	}
296	#endif /* HAVE_ALTIVEC */	217	#endif /* HAVE_ALTIVEC */
297	}	218	}

libavcodec/ppc/dsputil_ppc.h+0−154

@@ -1,154 +0,0 @@
1	/*
2	* Copyright (c) 2003-2004 Romain Dolbeau <romain@dolbeau.org>
3	*
4	* This file is part of FFmpeg.
5	*
6	* FFmpeg is free software; you can redistribute it and/or
7	* modify it under the terms of the GNU Lesser General Public
8	* License as published by the Free Software Foundation; either
9	* version 2.1 of the License, or (at your option) any later version.
10	*
11	* FFmpeg is distributed in the hope that it will be useful,
12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14	* Lesser General Public License for more details.
15	*
16	* You should have received a copy of the GNU Lesser General Public
17	* License along with FFmpeg; if not, write to the Free Software
18	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19	*/
20
21	#ifndef AVCODEC_PPC_DSPUTIL_PPC_H
22	#define AVCODEC_PPC_DSPUTIL_PPC_H
23
24	#include "config.h"
25
26	#if CONFIG_POWERPC_PERF
27	void powerpc_display_perf_report(void);
28	/* the 604* have 2, the G3* have 4, the G4s have 6,
29	and the G5 are completely different (they MUST use
30	ARCH_PPC64, and let's hope all future 64 bis PPC
31	will use the same PMCs... */
32	#define POWERPC_NUM_PMC_ENABLED 6
33	/* if you add to the enum below, also add to the perfname array
34	in dsputil_ppc.c */
35	enum powerpc_perf_index {
36	altivec_fft_num = 0,
37	altivec_gmc1_num,
38	altivec_dct_unquantize_h263_num,
39	altivec_fdct,
40	altivec_idct_add_num,
41	altivec_idct_put_num,
42	altivec_put_pixels16_num,
43	altivec_avg_pixels16_num,
44	altivec_avg_pixels8_num,
45	altivec_put_pixels8_xy2_num,
46	altivec_put_no_rnd_pixels8_xy2_num,
47	altivec_put_pixels16_xy2_num,
48	altivec_put_no_rnd_pixels16_xy2_num,
49	altivec_hadamard8_diff8x8_num,
50	altivec_hadamard8_diff16_num,
51	altivec_avg_pixels8_xy2_num,
52	powerpc_clear_blocks_dcbz32,
53	powerpc_clear_blocks_dcbz128,
54	altivec_put_h264_chroma_mc8_num,
55	altivec_avg_h264_chroma_mc8_num,
56	altivec_put_h264_qpel16_h_lowpass_num,
57	altivec_avg_h264_qpel16_h_lowpass_num,
58	altivec_put_h264_qpel16_v_lowpass_num,
59	altivec_avg_h264_qpel16_v_lowpass_num,
60	altivec_put_h264_qpel16_hv_lowpass_num,
61	altivec_avg_h264_qpel16_hv_lowpass_num,
62	powerpc_perf_total
63	};
64	enum powerpc_data_index {
65	powerpc_data_min = 0,
66	powerpc_data_max,
67	powerpc_data_sum,
68	powerpc_data_num,
69	powerpc_data_total
70	};
71	extern unsigned long long perfdata[POWERPC_NUM_PMC_ENABLED][powerpc_perf_total][powerpc_data_total];
72
73	#if !ARCH_PPC64
74	#define POWERP_PMC_DATATYPE unsigned long
75	#define POWERPC_GET_PMC1(a) __asm__ volatile("mfspr %0, 937" : "=r" (a))
76	#define POWERPC_GET_PMC2(a) __asm__ volatile("mfspr %0, 938" : "=r" (a))
77	#if (POWERPC_NUM_PMC_ENABLED > 2)
78	#define POWERPC_GET_PMC3(a) __asm__ volatile("mfspr %0, 941" : "=r" (a))
79	#define POWERPC_GET_PMC4(a) __asm__ volatile("mfspr %0, 942" : "=r" (a))
80	#else
81	#define POWERPC_GET_PMC3(a) do {} while (0)
82	#define POWERPC_GET_PMC4(a) do {} while (0)
83	#endif
84	#if (POWERPC_NUM_PMC_ENABLED > 4)
85	#define POWERPC_GET_PMC5(a) __asm__ volatile("mfspr %0, 929" : "=r" (a))
86	#define POWERPC_GET_PMC6(a) __asm__ volatile("mfspr %0, 930" : "=r" (a))
87	#else
88	#define POWERPC_GET_PMC5(a) do {} while (0)
89	#define POWERPC_GET_PMC6(a) do {} while (0)
90	#endif
91	#else /* ARCH_PPC64 */
92	#define POWERP_PMC_DATATYPE unsigned long long
93	#define POWERPC_GET_PMC1(a) __asm__ volatile("mfspr %0, 771" : "=r" (a))
94	#define POWERPC_GET_PMC2(a) __asm__ volatile("mfspr %0, 772" : "=r" (a))
95	#if (POWERPC_NUM_PMC_ENABLED > 2)
96	#define POWERPC_GET_PMC3(a) __asm__ volatile("mfspr %0, 773" : "=r" (a))
97	#define POWERPC_GET_PMC4(a) __asm__ volatile("mfspr %0, 774" : "=r" (a))
98	#else
99	#define POWERPC_GET_PMC3(a) do {} while (0)
100	#define POWERPC_GET_PMC4(a) do {} while (0)
101	#endif
102	#if (POWERPC_NUM_PMC_ENABLED > 4)
103	#define POWERPC_GET_PMC5(a) __asm__ volatile("mfspr %0, 775" : "=r" (a))
104	#define POWERPC_GET_PMC6(a) __asm__ volatile("mfspr %0, 776" : "=r" (a))
105	#else
106	#define POWERPC_GET_PMC5(a) do {} while (0)
107	#define POWERPC_GET_PMC6(a) do {} while (0)
108	#endif
109	#endif /* ARCH_PPC64 */
110	#define POWERPC_PERF_DECLARE(a, cond) \
111	POWERP_PMC_DATATYPE \
112	pmc_start[POWERPC_NUM_PMC_ENABLED], \
113	pmc_stop[POWERPC_NUM_PMC_ENABLED], \
114	pmc_loop_index;
115	#define POWERPC_PERF_START_COUNT(a, cond) do { \
116	POWERPC_GET_PMC6(pmc_start[5]); \
117	POWERPC_GET_PMC5(pmc_start[4]); \
118	POWERPC_GET_PMC4(pmc_start[3]); \
119	POWERPC_GET_PMC3(pmc_start[2]); \
120	POWERPC_GET_PMC2(pmc_start[1]); \
121	POWERPC_GET_PMC1(pmc_start[0]); \
122	} while (0)
123	#define POWERPC_PERF_STOP_COUNT(a, cond) do { \
124	POWERPC_GET_PMC1(pmc_stop[0]); \
125	POWERPC_GET_PMC2(pmc_stop[1]); \
126	POWERPC_GET_PMC3(pmc_stop[2]); \
127	POWERPC_GET_PMC4(pmc_stop[3]); \
128	POWERPC_GET_PMC5(pmc_stop[4]); \
129	POWERPC_GET_PMC6(pmc_stop[5]); \
130	if (cond) { \
131	for(pmc_loop_index = 0; \
132	pmc_loop_index < POWERPC_NUM_PMC_ENABLED; \
133	pmc_loop_index++) { \
134	if (pmc_stop[pmc_loop_index] >= pmc_start[pmc_loop_index]) { \
135	POWERP_PMC_DATATYPE diff = \
136	pmc_stop[pmc_loop_index] - pmc_start[pmc_loop_index]; \
137	if (diff < perfdata[pmc_loop_index][a][powerpc_data_min]) \
138	perfdata[pmc_loop_index][a][powerpc_data_min] = diff; \
139	if (diff > perfdata[pmc_loop_index][a][powerpc_data_max]) \
140	perfdata[pmc_loop_index][a][powerpc_data_max] = diff; \
141	perfdata[pmc_loop_index][a][powerpc_data_sum] += diff; \
142	perfdata[pmc_loop_index][a][powerpc_data_num] ++; \
143	} \
144	} \
145	} \
146	} while (0)
147	#else /* CONFIG_POWERPC_PERF */
148	// those are needed to avoid empty statements.
149	#define POWERPC_PERF_DECLARE(a, cond) int altivec_placeholder __attribute__ ((unused))
150	#define POWERPC_PERF_START_COUNT(a, cond) do {} while (0)
151	#define POWERPC_PERF_STOP_COUNT(a, cond) do {} while (0)
152	#endif /* CONFIG_POWERPC_PERF */
153
154	#endif /* AVCODEC_PPC_DSPUTIL_PPC_H */

libavcodec/ppc/fdct_altivec.c+0−7

 #endif
 #include "libavutil/common.h"
 #include "libavcodec/dsputil.h"
-#include "dsputil_ppc.h"
 #include "dsputil_altivec.h"
 #define vs16(v) ((vector signed short)(v))
 void fdct_altivec(int16_t *block)
 {
-POWERPC_PERF_DECLARE(altivec_fdct, 1);
     vector signed short *bp;
     vector float *cp;
     vector float b00, b10, b20, b30, b40, b50, b60, b70;
     vector float mzero, cnst, cnsts0, cnsts1, cnsts2;
     vector float x0, x1, x2, x3, x4, x5, x6, x7, x8;
-    POWERPC_PERF_START_COUNT(altivec_fdct, 1);
     /* setup constants {{{ */
     /* mzero = -0.0 */
     mzero = ((vector float)vec_splat_u32(-1));
 #undef CTS
     /* }}} */
-POWERPC_PERF_STOP_COUNT(altivec_fdct, 1);
 }
 /* vim:set foldmethod=marker foldlevel=0: */

libavcodec/ppc/fft_altivec.c+0−6

  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 #include "libavcodec/fft.h"
-#include "dsputil_ppc.h"
 #include "util_altivec.h"
 #include "dsputil_altivec.h"
  */
 static void ff_fft_calc_altivec(FFTContext *s, FFTComplex *z)
 {
-POWERPC_PERF_DECLARE(altivec_fft_num, s->nbits >= 6);
     register const vector float vczero = (const vector float)vec_splat_u32(0.);
     int ln = s->nbits;
     FFTComplex *cptr, *cptr1;
     int k;
-POWERPC_PERF_START_COUNT(altivec_fft_num, s->nbits >= 6);
     np = 1 << ln;
     {
         nblocks = nblocks >> 1;
         nloops = nloops << 1;
     } while (nblocks != 0);
-POWERPC_PERF_STOP_COUNT(altivec_fft_num, s->nbits >= 6);
 }
 av_cold void ff_fft_init_altivec(FFTContext *s)

libavcodec/ppc/gmc_altivec.c+0−8

  */
 #include "libavcodec/dsputil.h"
-#include "dsputil_ppc.h"
 #include "util_altivec.h"
 #include "types_altivec.h"
 #include "dsputil_altivec.h"
   altivec-enhanced gmc1. ATM this code assume stride is a multiple of 8,
   to preserve proper dst alignment.
 */
-#define GMC1_PERF_COND (h==8)
 void gmc1_altivec(uint8_t *dst /* align 8 */, uint8_t *src /* align1 */, int stride, int h, int x16, int y16, int rounder)
 {
-POWERPC_PERF_DECLARE(altivec_gmc1_num, GMC1_PERF_COND);
     const DECLARE_ALIGNED(16, unsigned short, rounder_a) = rounder;
     const DECLARE_ALIGNED(16, unsigned short, ABCD)[8] =
         {
     unsigned long dst_odd = (unsigned long)dst & 0x0000000F;
     unsigned long src_really_odd = (unsigned long)src & 0x0000000F;
-POWERPC_PERF_START_COUNT(altivec_gmc1_num, GMC1_PERF_COND);
     tempA = vec_ld(0, (unsigned short*)ABCD);
     Av = vec_splat(tempA, 0);
     Bv = vec_splat(tempA, 1);
         dst += stride;
         src += stride;
     }
-POWERPC_PERF_STOP_COUNT(altivec_gmc1_num, GMC1_PERF_COND);
 }

libavcodec/ppc/h264_altivec.c+0−1

@@ -22,7 +22,6 @@ · 21 unmodified lines
22	#include "libavcodec/h264data.h"	22	#include "libavcodec/h264data.h"
23	#include "libavcodec/h264dsp.h"	23	#include "libavcodec/h264dsp.h"
24		24
25	#include "dsputil_ppc.h"
26	#include "dsputil_altivec.h"	25	#include "dsputil_altivec.h"
27	#include "util_altivec.h"	26	#include "util_altivec.h"
28	#include "types_altivec.h"	27	#include "types_altivec.h"

libavcodec/ppc/h264_template_altivec.c+0−16

 static void PREFIX_h264_chroma_mc8_altivec(uint8_t * dst, uint8_t * src,
                                     int stride, int h, int x, int y) {
-  POWERPC_PERF_DECLARE(PREFIX_h264_chroma_mc8_num, 1);
     DECLARE_ALIGNED(16, signed int, ABCD)[4] =
                         {((8 - x) * (8 - y)),
                          ((    x) * (8 - y)),
     vec_s16 vsrc2ssH, vsrc3ssH, psum;
     vec_u8 vdst, ppsum, vfdst, fsum;
-  POWERPC_PERF_START_COUNT(PREFIX_h264_chroma_mc8_num, 1);
     if (((unsigned long)dst) % 16 == 0) {
         fperm = (vec_u8){0x10, 0x11, 0x12, 0x13,
                          0x14, 0x15, 0x16, 0x17,
             }
         }
     }
-    POWERPC_PERF_STOP_COUNT(PREFIX_h264_chroma_mc8_num, 1);
 }
 /* this code assume that stride % 16 == 0 */
 /* this code assume stride % 16 == 0 */
 static void PREFIX_h264_qpel16_h_lowpass_altivec(uint8_t * dst, uint8_t * src, int dstStride, int srcStride) {
-    POWERPC_PERF_DECLARE(PREFIX_h264_qpel16_h_lowpass_num, 1);
     register int i;
     LOAD_ZERO;
     vec_u8 sum, vdst, fsum;
-    POWERPC_PERF_START_COUNT(PREFIX_h264_qpel16_h_lowpass_num, 1);
     for (i = 0 ; i < 16 ; i ++) {
         vec_u8 srcR1 = vec_ld(-2, src);
         vec_u8 srcR2 = vec_ld(14, src);
         src += srcStride;
         dst += dstStride;
     }
-    POWERPC_PERF_STOP_COUNT(PREFIX_h264_qpel16_h_lowpass_num, 1);
 }
 /* this code assume stride % 16 == 0 */
 static void PREFIX_h264_qpel16_v_lowpass_altivec(uint8_t * dst, uint8_t * src, int dstStride, int srcStride) {
-    POWERPC_PERF_DECLARE(PREFIX_h264_qpel16_v_lowpass_num, 1);
     register int i;
     LOAD_ZERO;
     vec_u8 sum, vdst, fsum, srcP3a, srcP3b, srcP3;
-    POWERPC_PERF_START_COUNT(PREFIX_h264_qpel16_v_lowpass_num, 1);
     for (i = 0 ; i < 16 ; i++) {
         srcP3a = vec_ld(0, srcbis += srcStride);
         srcP3b = vec_ld(16, srcbis);
         dst += dstStride;
     }
-    POWERPC_PERF_STOP_COUNT(PREFIX_h264_qpel16_v_lowpass_num, 1);
 }
 /* this code assume stride % 16 == 0 *and* tmp is properly aligned */
 static void PREFIX_h264_qpel16_hv_lowpass_altivec(uint8_t * dst, int16_t * tmp, uint8_t * src, int dstStride, int tmpStride, int srcStride) {
-    POWERPC_PERF_DECLARE(PREFIX_h264_qpel16_hv_lowpass_num, 1);
     register int i;
     LOAD_ZERO;
     const vec_u8 permM2 = vec_lvsl(-2, src);
     vec_u8 fsum, sumv, sum, vdst;
     vec_s16 ssume, ssumo;
-    POWERPC_PERF_START_COUNT(PREFIX_h264_qpel16_hv_lowpass_num, 1);
     src -= (2 * srcStride);
     for (i = 0 ; i < 21 ; i ++) {
         vec_u8 srcM2, srcM1, srcP0, srcP1, srcP2, srcP3;
         dst += dstStride;
     }
-    POWERPC_PERF_STOP_COUNT(PREFIX_h264_qpel16_hv_lowpass_num, 1);
 }

libavcodec/ppc/idct_altivec.c+0−14

 #endif
 #include "libavcodec/dsputil.h"
 #include "types_altivec.h"
-#include "dsputil_ppc.h"
 #include "dsputil_altivec.h"
 #define IDCT_HALF                                       \
 void idct_put_altivec(uint8_t* dest, int stride, int16_t *blk)
 {
-POWERPC_PERF_DECLARE(altivec_idct_put_num, 1);
     vec_s16 *block = (vec_s16*)blk;
     vec_u8 tmp;
-#if CONFIG_POWERPC_PERF
-POWERPC_PERF_START_COUNT(altivec_idct_put_num, 1);
-#endif
     IDCT
 #define COPY(dest,src)                                          \
     COPY (dest, vx5)    dest += stride;
     COPY (dest, vx6)    dest += stride;
     COPY (dest, vx7)
-POWERPC_PERF_STOP_COUNT(altivec_idct_put_num, 1);
 }
 void idct_add_altivec(uint8_t* dest, int stride, int16_t *blk)
 {
-POWERPC_PERF_DECLARE(altivec_idct_add_num, 1);
     vec_s16 *block = (vec_s16*)blk;
     vec_u8 tmp;
     vec_s16 tmp2, tmp3;
     vec_u8 perm1;
     vec_u8 p0, p1, p;
-#if CONFIG_POWERPC_PERF
-POWERPC_PERF_START_COUNT(altivec_idct_add_num, 1);
-#endif
     IDCT
     p0 = vec_lvsl (0, dest);
     ADD (dest, vx5, perm1)      dest += stride;
     ADD (dest, vx6, perm0)      dest += stride;
     ADD (dest, vx7, perm1)
-POWERPC_PERF_STOP_COUNT(altivec_idct_add_num, 1);
 }

libavcodec/ppc/mpegvideo_altivec.c+0−5

 #include "libavcodec/dsputil.h"
 #include "libavcodec/mpegvideo.h"
-#include "dsputil_ppc.h"
 #include "util_altivec.h"
 #include "types_altivec.h"
 #include "dsputil_altivec.h"
 static void dct_unquantize_h263_altivec(MpegEncContext *s,
                                  DCTELEM *block, int n, int qscale)
 {
-POWERPC_PERF_DECLARE(altivec_dct_unquantize_h263_num, 1);
     int i, level, qmul, qadd;
     int nCoeffs;
     assert(s->block_last_index[n]>=0);
-POWERPC_PERF_START_COUNT(altivec_dct_unquantize_h263_num, 1);
     qadd = (qscale - 1) | 1;
     qmul = qscale << 1;
             block[0] = backup_0;
         }
     }
-POWERPC_PERF_STOP_COUNT(altivec_dct_unquantize_h263_num, nCoeffs == 63);
 }

Remove PPC perf counter support

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code