cortex-a8

I'm trying to implement the checksum computation code(2's complement addition) for NEON, using intrinsic. The current checksum computation is being carried out on ARM. My implementation fetches 128-bits at once from the memory into NEON registers and does SIMD (addition), and result is folded to a 16-bit number from a 128-bit number. Everything looks to be working fine, but my NEON implementation is consuming more time that of the ARM version. ARM version takes: 0.860000 s NEON version takes: 1.260000 s Note: Profiled using utilities from "time.h" The checksum function called 10,000 times from

If you see this popular pipeline diagram of ARM Cortex-A8 given in one of ARM presentations . It is clear that the instruction fetch stage takes 3 cycles, yet the first cycle is sort of discounted . But, why? Any thoughts? Thank you... From somewhat hidden paper on Cortex A8 : The fetch pipeline begins with the F0 stage where a new virtual address is generated. This address can either be a branch target address provided by a branch prediction for a previous instruction, or if there is no prediction made this cycle, the next address will be calculated sequentially from the fetch address used in

How to use the NEON comparison instructions in general? Here is a case, I want to use, Greater-than-or-equal-to instruction? Currently I have a, int x; ... ... ... if(x >= 0) { .... } In NEON, I would like to use x in the same way, just that x this time is a vector. int32x4_t x; ... ... ... if(vcgeq_s32(x, vdupq_n_s32(0))) // Whats the best way to achieve this effect? { .... } With SIMD it's not straightforward to go from a single scalar if/then to a test on multiple elements. Usually you want to test if any element is greater than or if all elements are greater than, and there will usually be

I'm using a Exynos 3110 processor (1 GHz Single-core ARM Cortex-A8, e.g. used in the Nexus S) and try to measure execution times of particular functions. I have an Android 4.0.3 running on the Nexus S. I tried the method from [1] How to measure program execution time in ARM Cortex-A8 processor? I loaded the kernel module to allow reading the register values in user mode. I am using the following program to test the counter: static inline unsigned int get_cyclecount (void) { unsigned int value; // Read CCNT Register asm volatile ("MRC p15, 0, %0, c9, c13, 0\t\n": "=r"(value)); return value; }

Here is a C++ code: #define ARR_SIZE_TEST ( 8 * 1024 * 1024 ) void cpp_tst_add( unsigned* x, unsigned* y ) { for ( register int i = 0; i < ARR_SIZE_TEST; ++i ) { x[ i ] = x[ i ] + y[ i ]; } } Here is a neon version: void neon_assm_tst_add( unsigned* x, unsigned* y ) { register unsigned i = ARR_SIZE_TEST >> 2; __asm__ __volatile__ ( ".loop1: \n\t" "vld1.32 {q0}, [%[x]] \n\t" "vld1.32 {q1}, [%[y]]! \n\t" "vadd.i32 q0 ,q0, q1 \n\t" "vst1.32 {q0}, [%[x]]! \n\t" "subs %[i], %[i], $1 \n\t" "bne .loop1 \n\t" : [x]"+r"(x), [y]"+r"(y), [i]"+r"(i) : : "memory" ); } Test function: void bench_simple_types

In ARM Cortex-A8 processor, I understand what NEON is, it is an SIMD co-processor. But is VFP(Vector Floating Point) unit, which is also a co-processor, works as a SIMD processor? If so which one is better to use? I read few links such as - Link1 Link2 . But not really very clear what they mean. They say that VFP was never intended to be used for SIMD but on Wiki I read the following - " The VFP architecture also supports execution of short vector instructions but these operate on each vector element sequentially and thus do not offer the performance of true SIMD (Single Instruction Multiple

I'm working on Cortex-A8 and Cortex-A9 in particular. I know that some architectures don't come with integer division, but what is the best way to do it other than convert to float, divide, convert to integer? Or is that indeed the best solution? Cheers! = ) The compiler normally includes a divide in its library, gcclib for example I have extracted them from gcc and use them directly: https://github.com/dwelch67/stm32vld/ then stm32f4d/adventure/gcclib going to float and back is probably not the best solution. you can try it and see how fast it is...This is a multiply but could as easily make