이상한 나라의 행복한 브라운

Tue Jan 26 12:47:44 EST 2010 · Posted by

Hi,

Here is the latest version of the patch, after review on the ML.

Adds the Performance Events support for ARMv7 processor, using
the PMNC unit in HW.

Supports the following:
- Cortex-A8 and Cortex-A9 processors,
- dynamic detection of the number of available counters,
   based on the PMCR value,
- runtime detection of the CPU arch (v6 or v7)
   and model (Cortex-A8 or Cortex-A9)

Tested on OMAP3 (Cortex-A8) only.

Signed-off-by: Jean Pihet <jpihet at mvista.com>

Regards,
Jean

On Tuesday 26 January 2010 17:11:44 Jean Pihet wrote:
> Hi,
>
> On Tuesday 26 January 2010 17:09:29 Jamie Iles wrote:
> > On Tue, Jan 26, 2010 at 05:03:44PM +0100, Tomasz Fujak wrote:
> > > Where do I find a repository that contains the latest performance
> > > events/ARM efforts?
> >
> > I've just submitted the generic/ARMv6 stuff to the patch system.
> > Hopefully this will end up in Russell's tree soon.
>
> I am about to submit the patch for ARMv7, so hopefully it will end up in
> Russell's tree soon as well.
>
> > Jamie
>
> Jean
---

From 6e8e6e710c93eb16885c5c789f689a86d824bdba Mon Sep 17 00:00:00 2001
From: Jean Pihet <jpihet at mvista.com>
Date: Fri, 18 Dec 2009 17:46:21 +0100
Subject: [PATCH] arm/perfevents: add support for ARMv7

Adds the Performance Events support for ARMv7 processor, using
the PMNC unit in HW.

Supports the following:
- Cortex-A8 and Cortex-A9 processors,
- dynamic detection of the number of available counters,
   based on the PMCR value,
- runtime detection of the CPU arch (v6 or v7)
   and model (Cortex-A8 or Cortex-A9)

Tested on OMAP3 (Cortex-A8) only.

Signed-off-by: Jean Pihet <jpihet at mvista.com>
---
 arch/arm/Kconfig             |    2 +-
 arch/arm/kernel/perf_event.c |  934 
+++++++++++++++++++++++++++++++++++++++++-
 2 files changed, 931 insertions(+), 5 deletions(-)

diff --git a/arch/arm/Kconfig b/arch/arm/Kconfig
index 6cbcba7..bc177cd 100644
--- a/arch/arm/Kconfig
+++ b/arch/arm/Kconfig
@@ -1181,7 +1181,7 @@ config HIGHPTE
 
 config HW_PERF_EVENTS
 	bool "Enable hardware performance counter support for perf events"
-	depends on PERF_EVENTS && CPU_HAS_PMU && CPU_V6
+	depends on PERF_EVENTS && CPU_HAS_PMU && (CPU_V6 || CPU_V7)
 	default y
 	help
 	  Enable hardware performance counter support for perf events. If
diff --git a/arch/arm/kernel/perf_event.c b/arch/arm/kernel/perf_event.c
index 4ef3c50..6d030d8 100644
--- a/arch/arm/kernel/perf_event.c
+++ b/arch/arm/kernel/perf_event.c
@@ -5,6 +5,9 @@
  *
  * Copyright (C) 2009 picoChip Designs, Ltd., Jamie Iles
  *
+ * ARMv7 support: Jean Pihet <jpihet at mvista.com>
+ * 2010 (c) MontaVista Software, LLC.
+ *
  * This code is based on the sparc64 perf event code, which is in turn based
  * on the x86 code. Callchain code is based on the ARM OProfile backtrace
  * code.
@@ -35,8 +38,12 @@ DEFINE_SPINLOCK(pmu_lock);
  * ARMv6 supports a maximum of 3 events, starting from index 1. If we add
  * another platform that supports more, we need to increase this to be the
  * largest of all platforms.
+ *
+ * ARMv7 supports up to 32 events:
+ *  cycle counter CCNT + 31 events counters CNT0..30.
+ *  Cortex-A8 has 1+4 counters, Cortex-A9 has 1+6 counters
  */
-#define ARMPMU_MAX_HWEVENTS		4
+#define ARMPMU_MAX_HWEVENTS		33
 
 /* The events for a given CPU. */
 struct cpu_hw_events {
@@ -61,7 +68,7 @@ struct cpu_hw_events {
 DEFINE_PER_CPU(struct cpu_hw_events, cpu_hw_events);
 
 struct arm_pmu {
-	const char	*name;
+	char		*name;
 	irqreturn_t	(*handle_irq)(int irq_num, void *dev);
 	void		(*enable)(struct hw_perf_event *evt, int idx);
 	void		(*disable)(struct hw_perf_event *evt, int idx);
@@ -1173,6 +1180,903 @@ static const struct arm_pmu armv6mpcore_pmu = {
 	.max_period		= (1LLU << 32) - 1,
 };
 
+/*
+ * ARMv7 Cortex-A8 and Cortex-A9 Performance Events handling code.
+ *
+ * Copied from ARMv6 code, with the low level code inspired
+ *  by the ARMv7 Oprofile code.
+ *
+ * Cortex-A8 has up to 4 configurable performance counters and
+ *  a single cycle counter.
+ * Cortex-A9 has up to 31 configurable performance counters and
+ *  a single cycle counter.
+ *
+ * All counters can be enabled/disabled and IRQ masked separately. The cycle
+ *  counter and all 4 performance counters together can be reset separately.
+ */
+
+#define ARMV7_PMU_CORTEX_A8_NAME		"ARMv7 Cortex-A8"
+
+#define ARMV7_PMU_CORTEX_A9_NAME		"ARMv7 Cortex-A9"
+
+/* Common ARMv7 event types */
+enum armv7_perf_types {
+	ARMV7_PERFCTR_PMNC_SW_INCR		= 0x00,
+	ARMV7_PERFCTR_IFETCH_MISS		= 0x01,
+	ARMV7_PERFCTR_ITLB_MISS			= 0x02,
+	ARMV7_PERFCTR_DCACHE_REFILL		= 0x03,
+	ARMV7_PERFCTR_DCACHE_ACCESS		= 0x04,
+	ARMV7_PERFCTR_DTLB_REFILL		= 0x05,
+	ARMV7_PERFCTR_DREAD			= 0x06,
+	ARMV7_PERFCTR_DWRITE			= 0x07,
+
+	ARMV7_PERFCTR_EXC_TAKEN			= 0x09,
+	ARMV7_PERFCTR_EXC_EXECUTED		= 0x0A,
+	ARMV7_PERFCTR_CID_WRITE			= 0x0B,
+	/* ARMV7_PERFCTR_PC_WRITE is equivalent to HW_BRANCH_INSTRUCTIONS.
+	 * It counts:
+	 *  - all branch instructions,
+	 *  - instructions that explicitly write the PC,
+	 *  - exception generating instructions.
+	 */
+	ARMV7_PERFCTR_PC_WRITE			= 0x0C,
+	ARMV7_PERFCTR_PC_IMM_BRANCH		= 0x0D,
+	ARMV7_PERFCTR_UNALIGNED_ACCESS		= 0x0F,
+	ARMV7_PERFCTR_PC_BRANCH_MIS_PRED	= 0x10,
+	ARMV7_PERFCTR_CLOCK_CYCLES		= 0x11,
+
+	ARMV7_PERFCTR_PC_BRANCH_MIS_USED	= 0x12,
+
+	ARMV7_PERFCTR_CPU_CYCLES		= 0xFF
+};
+
+/* ARMv7 Cortex-A8 specific event types */
+enum armv7_a8_perf_types {
+	ARMV7_PERFCTR_INSTR_EXECUTED		= 0x08,
+
+	ARMV7_PERFCTR_PC_PROC_RETURN		= 0x0E,
+
+	ARMV7_PERFCTR_WRITE_BUFFER_FULL		= 0x40,
+	ARMV7_PERFCTR_L2_STORE_MERGED		= 0x41,
+	ARMV7_PERFCTR_L2_STORE_BUFF		= 0x42,
+	ARMV7_PERFCTR_L2_ACCESS			= 0x43,
+	ARMV7_PERFCTR_L2_CACH_MISS		= 0x44,
+	ARMV7_PERFCTR_AXI_READ_CYCLES		= 0x45,
+	ARMV7_PERFCTR_AXI_WRITE_CYCLES		= 0x46,
+	ARMV7_PERFCTR_MEMORY_REPLAY		= 0x47,
+	ARMV7_PERFCTR_UNALIGNED_ACCESS_REPLAY	= 0x48,
+	ARMV7_PERFCTR_L1_DATA_MISS		= 0x49,
+	ARMV7_PERFCTR_L1_INST_MISS		= 0x4A,
+	ARMV7_PERFCTR_L1_DATA_COLORING		= 0x4B,
+	ARMV7_PERFCTR_L1_NEON_DATA		= 0x4C,
+	ARMV7_PERFCTR_L1_NEON_CACH_DATA		= 0x4D,
+	ARMV7_PERFCTR_L2_NEON			= 0x4E,
+	ARMV7_PERFCTR_L2_NEON_HIT		= 0x4F,
+	ARMV7_PERFCTR_L1_INST			= 0x50,
+	ARMV7_PERFCTR_PC_RETURN_MIS_PRED	= 0x51,
+	ARMV7_PERFCTR_PC_BRANCH_FAILED		= 0x52,
+	ARMV7_PERFCTR_PC_BRANCH_TAKEN		= 0x53,
+	ARMV7_PERFCTR_PC_BRANCH_EXECUTED	= 0x54,
+	ARMV7_PERFCTR_OP_EXECUTED		= 0x55,
+	ARMV7_PERFCTR_CYCLES_INST_STALL		= 0x56,
+	ARMV7_PERFCTR_CYCLES_INST		= 0x57,
+	ARMV7_PERFCTR_CYCLES_NEON_DATA_STALL	= 0x58,
+	ARMV7_PERFCTR_CYCLES_NEON_INST_STALL	= 0x59,
+	ARMV7_PERFCTR_NEON_CYCLES		= 0x5A,
+
+	ARMV7_PERFCTR_PMU0_EVENTS		= 0x70,
+	ARMV7_PERFCTR_PMU1_EVENTS		= 0x71,
+	ARMV7_PERFCTR_PMU_EVENTS		= 0x72,
+};
+
+/* ARMv7 Cortex-A9 specific event types */
+enum armv7_a9_perf_types {
+	ARMV7_PERFCTR_JAVA_HW_BYTECODE_EXEC	= 0x40,
+	ARMV7_PERFCTR_JAVA_SW_BYTECODE_EXEC	= 0x41,
+	ARMV7_PERFCTR_JAZELLE_BRANCH_EXEC	= 0x42,
+
+	ARMV7_PERFCTR_COHERENT_LINE_MISS	= 0x50,
+	ARMV7_PERFCTR_COHERENT_LINE_HIT		= 0x51,
+
+	ARMV7_PERFCTR_ICACHE_DEP_STALL_CYCLES	= 0x60,
+	ARMV7_PERFCTR_DCACHE_DEP_STALL_CYCLES	= 0x61,
+	ARMV7_PERFCTR_TLB_MISS_DEP_STALL_CYCLES	= 0x62,
+	ARMV7_PERFCTR_STREX_EXECUTED_PASSED	= 0x63,
+	ARMV7_PERFCTR_STREX_EXECUTED_FAILED	= 0x64,
+	ARMV7_PERFCTR_DATA_EVICTION		= 0x65,
+	ARMV7_PERFCTR_ISSUE_STAGE_NO_INST	= 0x66,
+	ARMV7_PERFCTR_ISSUE_STAGE_EMPTY		= 0x67,
+	ARMV7_PERFCTR_INST_OUT_OF_RENAME_STAGE	= 0x68,
+
+	ARMV7_PERFCTR_PREDICTABLE_FUNCT_RETURNS	= 0x6E,
+
+	ARMV7_PERFCTR_MAIN_UNIT_EXECUTED_INST	= 0x70,
+	ARMV7_PERFCTR_SECOND_UNIT_EXECUTED_INST	= 0x71,
+	ARMV7_PERFCTR_LD_ST_UNIT_EXECUTED_INST	= 0x72,
+	ARMV7_PERFCTR_FP_EXECUTED_INST		= 0x73,
+	ARMV7_PERFCTR_NEON_EXECUTED_INST	= 0x74,
+
+	ARMV7_PERFCTR_PLD_FULL_DEP_STALL_CYCLES	= 0x80,
+	ARMV7_PERFCTR_DATA_WR_DEP_STALL_CYCLES	= 0x81,
+	ARMV7_PERFCTR_ITLB_MISS_DEP_STALL_CYCLES	= 0x82,
+	ARMV7_PERFCTR_DTLB_MISS_DEP_STALL_CYCLES	= 0x83,
+	ARMV7_PERFCTR_MICRO_ITLB_MISS_DEP_STALL_CYCLES	= 0x84,
+	ARMV7_PERFCTR_MICRO_DTLB_MISS_DEP_STALL_CYCLES 	= 0x85,
+	ARMV7_PERFCTR_DMB_DEP_STALL_CYCLES	= 0x86,
+
+	ARMV7_PERFCTR_INTGR_CLK_ENABLED_CYCLES	= 0x8A,
+	ARMV7_PERFCTR_DATA_ENGINE_CLK_EN_CYCLES	= 0x8B,
+
+	ARMV7_PERFCTR_ISB_INST			= 0x90,
+	ARMV7_PERFCTR_DSB_INST			= 0x91,
+	ARMV7_PERFCTR_DMB_INST			= 0x92,
+	ARMV7_PERFCTR_EXT_INTERRUPTS		= 0x93,
+
+	ARMV7_PERFCTR_PLE_CACHE_LINE_RQST_COMPLETED	= 0xA0,
+	ARMV7_PERFCTR_PLE_CACHE_LINE_RQST_SKIPPED	= 0xA1,
+	ARMV7_PERFCTR_PLE_FIFO_FLUSH		= 0xA2,
+	ARMV7_PERFCTR_PLE_RQST_COMPLETED	= 0xA3,
+	ARMV7_PERFCTR_PLE_FIFO_OVERFLOW		= 0xA4,
+	ARMV7_PERFCTR_PLE_RQST_PROG		= 0xA5
+};
+
+/*
+ * Cortex-A8 HW events mapping
+ *
+ * The hardware events that we support. We do support cache operations but
+ * we have harvard caches and no way to combine instruction and data
+ * accesses/misses in hardware.
+ */
+static const unsigned armv7_a8_perf_map[PERF_COUNT_HW_MAX] = {
+	[PERF_COUNT_HW_CPU_CYCLES]	    = ARMV7_PERFCTR_CPU_CYCLES,
+	[PERF_COUNT_HW_INSTRUCTIONS]	    = ARMV7_PERFCTR_INSTR_EXECUTED,
+	[PERF_COUNT_HW_CACHE_REFERENCES]    = HW_OP_UNSUPPORTED,
+	[PERF_COUNT_HW_CACHE_MISSES]	    = HW_OP_UNSUPPORTED,
+	[PERF_COUNT_HW_BRANCH_INSTRUCTIONS] = ARMV7_PERFCTR_PC_WRITE,
+	[PERF_COUNT_HW_BRANCH_MISSES]	    = ARMV7_PERFCTR_PC_BRANCH_MIS_PRED,
+	[PERF_COUNT_HW_BUS_CYCLES]	    = ARMV7_PERFCTR_CLOCK_CYCLES,
+};
+
+static const unsigned armv7_a8_perf_cache_map[PERF_COUNT_HW_CACHE_MAX]
+					  [PERF_COUNT_HW_CACHE_OP_MAX]
+					  [PERF_COUNT_HW_CACHE_RESULT_MAX] = {
+	[C(L1D)] = {
+		/*
+		 * The performance counters don't differentiate between read
+		 * and write accesses/misses so this isn't strictly correct,
+		 * but it's the best we can do. Writes and reads get
+		 * combined.
+		 */
+		[C(OP_READ)] = {
+			[C(RESULT_ACCESS)]	= ARMV7_PERFCTR_DCACHE_ACCESS,
+			[C(RESULT_MISS)]	= ARMV7_PERFCTR_DCACHE_REFILL,
+		},
+		[C(OP_WRITE)] = {
+			[C(RESULT_ACCESS)]	= ARMV7_PERFCTR_DCACHE_ACCESS,
+			[C(RESULT_MISS)]	= ARMV7_PERFCTR_DCACHE_REFILL,
+		},
+		[C(OP_PREFETCH)] = {
+			[C(RESULT_ACCESS)]	= CACHE_OP_UNSUPPORTED,
+			[C(RESULT_MISS)]	= CACHE_OP_UNSUPPORTED,
+		},
+	},
+	[C(L1I)] = {
+		[C(OP_READ)] = {
+			[C(RESULT_ACCESS)]	= ARMV7_PERFCTR_L1_INST,
+			[C(RESULT_MISS)]	= ARMV7_PERFCTR_L1_INST_MISS,
+		},
+		[C(OP_WRITE)] = {
+			[C(RESULT_ACCESS)]	= ARMV7_PERFCTR_L1_INST,
+			[C(RESULT_MISS)]	= ARMV7_PERFCTR_L1_INST_MISS,
+		},
+		[C(OP_PREFETCH)] = {
+			[C(RESULT_ACCESS)]	= CACHE_OP_UNSUPPORTED,
+			[C(RESULT_MISS)]	= CACHE_OP_UNSUPPORTED,
+		},
+	},
+	[C(LL)] = {
+		[C(OP_READ)] = {
+			[C(RESULT_ACCESS)]	= ARMV7_PERFCTR_L2_ACCESS,
+			[C(RESULT_MISS)]	= ARMV7_PERFCTR_L2_CACH_MISS,
+		},
+		[C(OP_WRITE)] = {
+			[C(RESULT_ACCESS)]	= ARMV7_PERFCTR_L2_ACCESS,
+			[C(RESULT_MISS)]	= ARMV7_PERFCTR_L2_CACH_MISS,
+		},
+		[C(OP_PREFETCH)] = {
+			[C(RESULT_ACCESS)]	= CACHE_OP_UNSUPPORTED,
+			[C(RESULT_MISS)]	= CACHE_OP_UNSUPPORTED,
+		},
+	},
+	[C(DTLB)] = {
+		/*
+		 * Only ITLB misses and DTLB refills are supported.
+		 * If users want the DTLB refills misses a raw counter
+		 * must be used.
+		 */
+		[C(OP_READ)] = {
+			[C(RESULT_ACCESS)]	= CACHE_OP_UNSUPPORTED,
+			[C(RESULT_MISS)]	= ARMV7_PERFCTR_DTLB_REFILL,
+		},
+		[C(OP_WRITE)] = {
+			[C(RESULT_ACCESS)]	= CACHE_OP_UNSUPPORTED,
+			[C(RESULT_MISS)]	= ARMV7_PERFCTR_DTLB_REFILL,
+		},
+		[C(OP_PREFETCH)] = {
+			[C(RESULT_ACCESS)]	= CACHE_OP_UNSUPPORTED,
+			[C(RESULT_MISS)]	= CACHE_OP_UNSUPPORTED,
+		},
+	},
+	[C(ITLB)] = {
+		[C(OP_READ)] = {
+			[C(RESULT_ACCESS)]	= CACHE_OP_UNSUPPORTED,
+			[C(RESULT_MISS)]	= ARMV7_PERFCTR_ITLB_MISS,
+		},
+		[C(OP_WRITE)] = {
+			[C(RESULT_ACCESS)]	= CACHE_OP_UNSUPPORTED,
+			[C(RESULT_MISS)]	= ARMV7_PERFCTR_ITLB_MISS,
+		},
+		[C(OP_PREFETCH)] = {
+			[C(RESULT_ACCESS)]	= CACHE_OP_UNSUPPORTED,
+			[C(RESULT_MISS)]	= CACHE_OP_UNSUPPORTED,
+		},
+	},
+	[C(BPU)] = {
+		[C(OP_READ)] = {
+			[C(RESULT_ACCESS)]	= ARMV7_PERFCTR_PC_WRITE,
+			[C(RESULT_MISS)]
+					= ARMV7_PERFCTR_PC_BRANCH_MIS_PRED,
+		},
+		[C(OP_WRITE)] = {
+			[C(RESULT_ACCESS)]	= ARMV7_PERFCTR_PC_WRITE,
+			[C(RESULT_MISS)]
+					= ARMV7_PERFCTR_PC_BRANCH_MIS_PRED,
+		},
+		[C(OP_PREFETCH)] = {
+			[C(RESULT_ACCESS)]	= CACHE_OP_UNSUPPORTED,
+			[C(RESULT_MISS)]	= CACHE_OP_UNSUPPORTED,
+		},
+	},
+};
+
+/*
+ * Cortex-A9 HW events mapping
+ */
+static const unsigned armv7_a9_perf_map[PERF_COUNT_HW_MAX] = {
+	[PERF_COUNT_HW_CPU_CYCLES]	    = ARMV7_PERFCTR_CPU_CYCLES,
+	[PERF_COUNT_HW_INSTRUCTIONS]	    =
+					ARMV7_PERFCTR_INST_OUT_OF_RENAME_STAGE,
+	[PERF_COUNT_HW_CACHE_REFERENCES]    = ARMV7_PERFCTR_COHERENT_LINE_HIT,
+	[PERF_COUNT_HW_CACHE_MISSES]	    = ARMV7_PERFCTR_COHERENT_LINE_MISS,
+	[PERF_COUNT_HW_BRANCH_INSTRUCTIONS] = ARMV7_PERFCTR_PC_WRITE,
+	[PERF_COUNT_HW_BRANCH_MISSES]	    = ARMV7_PERFCTR_PC_BRANCH_MIS_PRED,
+	[PERF_COUNT_HW_BUS_CYCLES]	    = ARMV7_PERFCTR_CLOCK_CYCLES,
+};
+
+static const unsigned armv7_a9_perf_cache_map[PERF_COUNT_HW_CACHE_MAX]
+					  [PERF_COUNT_HW_CACHE_OP_MAX]
+					  [PERF_COUNT_HW_CACHE_RESULT_MAX] = {
+	[C(L1D)] = {
+		/*
+		 * The performance counters don't differentiate between read
+		 * and write accesses/misses so this isn't strictly correct,
+		 * but it's the best we can do. Writes and reads get
+		 * combined.
+		 */
+		[C(OP_READ)] = {
+			[C(RESULT_ACCESS)]	= ARMV7_PERFCTR_DCACHE_ACCESS,
+			[C(RESULT_MISS)]	= ARMV7_PERFCTR_DCACHE_REFILL,
+		},
+		[C(OP_WRITE)] = {
+			[C(RESULT_ACCESS)]	= ARMV7_PERFCTR_DCACHE_ACCESS,
+			[C(RESULT_MISS)]	= ARMV7_PERFCTR_DCACHE_REFILL,
+		},
+		[C(OP_PREFETCH)] = {
+			[C(RESULT_ACCESS)]	= CACHE_OP_UNSUPPORTED,
+			[C(RESULT_MISS)]	= CACHE_OP_UNSUPPORTED,
+		},
+	},
+	[C(L1I)] = {
+		[C(OP_READ)] = {
+			[C(RESULT_ACCESS)]	= CACHE_OP_UNSUPPORTED,
+			[C(RESULT_MISS)]	= ARMV7_PERFCTR_IFETCH_MISS,
+		},
+		[C(OP_WRITE)] = {
+			[C(RESULT_ACCESS)]	= CACHE_OP_UNSUPPORTED,
+			[C(RESULT_MISS)]	= ARMV7_PERFCTR_IFETCH_MISS,
+		},
+		[C(OP_PREFETCH)] = {
+			[C(RESULT_ACCESS)]	= CACHE_OP_UNSUPPORTED,
+			[C(RESULT_MISS)]	= CACHE_OP_UNSUPPORTED,
+		},
+	},
+	[C(LL)] = {
+		[C(OP_READ)] = {
+			[C(RESULT_ACCESS)]	= CACHE_OP_UNSUPPORTED,
+			[C(RESULT_MISS)]	= CACHE_OP_UNSUPPORTED,
+		},
+		[C(OP_WRITE)] = {
+			[C(RESULT_ACCESS)]	= CACHE_OP_UNSUPPORTED,
+			[C(RESULT_MISS)]	= CACHE_OP_UNSUPPORTED,
+		},
+		[C(OP_PREFETCH)] = {
+			[C(RESULT_ACCESS)]	= CACHE_OP_UNSUPPORTED,
+			[C(RESULT_MISS)]	= CACHE_OP_UNSUPPORTED,
+		},
+	},
+	[C(DTLB)] = {
+		/*
+		 * Only ITLB misses and DTLB refills are supported.
+		 * If users want the DTLB refills misses a raw counter
+		 * must be used.
+		 */
+		[C(OP_READ)] = {
+			[C(RESULT_ACCESS)]	= CACHE_OP_UNSUPPORTED,
+			[C(RESULT_MISS)]	= ARMV7_PERFCTR_DTLB_REFILL,
+		},
+		[C(OP_WRITE)] = {
+			[C(RESULT_ACCESS)]	= CACHE_OP_UNSUPPORTED,
+			[C(RESULT_MISS)]	= ARMV7_PERFCTR_DTLB_REFILL,
+		},
+		[C(OP_PREFETCH)] = {
+			[C(RESULT_ACCESS)]	= CACHE_OP_UNSUPPORTED,
+			[C(RESULT_MISS)]	= CACHE_OP_UNSUPPORTED,
+		},
+	},
+	[C(ITLB)] = {
+		[C(OP_READ)] = {
+			[C(RESULT_ACCESS)]	= CACHE_OP_UNSUPPORTED,
+			[C(RESULT_MISS)]	= ARMV7_PERFCTR_ITLB_MISS,
+		},
+		[C(OP_WRITE)] = {
+			[C(RESULT_ACCESS)]	= CACHE_OP_UNSUPPORTED,
+			[C(RESULT_MISS)]	= ARMV7_PERFCTR_ITLB_MISS,
+		},
+		[C(OP_PREFETCH)] = {
+			[C(RESULT_ACCESS)]	= CACHE_OP_UNSUPPORTED,
+			[C(RESULT_MISS)]	= CACHE_OP_UNSUPPORTED,
+		},
+	},
+	[C(BPU)] = {
+		[C(OP_READ)] = {
+			[C(RESULT_ACCESS)]	= ARMV7_PERFCTR_PC_WRITE,
+			[C(RESULT_MISS)]
+					= ARMV7_PERFCTR_PC_BRANCH_MIS_PRED,
+		},
+		[C(OP_WRITE)] = {
+			[C(RESULT_ACCESS)]	= ARMV7_PERFCTR_PC_WRITE,
+			[C(RESULT_MISS)]
+					= ARMV7_PERFCTR_PC_BRANCH_MIS_PRED,
+		},
+		[C(OP_PREFETCH)] = {
+			[C(RESULT_ACCESS)]	= CACHE_OP_UNSUPPORTED,
+			[C(RESULT_MISS)]	= CACHE_OP_UNSUPPORTED,
+		},
+	},
+};
+
+/*
+ * Perf Events counters
+ */
+enum armv7_counters {
+	ARMV7_CYCLE_COUNTER 		= 1,	/* Cycle counter */
+	ARMV7_COUNTER0			= 2,	/* First event counter */
+};
+
+/*
+ * The cycle counter is ARMV7_CYCLE_COUNTER.
+ * The first event counter is ARMV7_COUNTER0.
+ * The last event counter is (ARMV7_COUNTER0 + armpmu->num_events - 1).
+ */
+#define	ARMV7_COUNTER_LAS	(ARMV7_COUNTER0 + armpmu->num_events - 1)
+
+/*
+ * ARMv7 low level PMNC access
+ */
+
+/*
+ * Per-CPU PMNC: config reg
+ */
+#define ARMV7_PMNC_E		(1 << 0) /* Enable all counters */
+#define ARMV7_PMNC_P		(1 << 1) /* Reset all counters */
+#define ARMV7_PMNC_C		(1 << 2) /* Cycle counter reset */
+#define ARMV7_PMNC_D		(1 << 3) /* CCNT counts every 64th cpu cycle */
+#define ARMV7_PMNC_X		(1 << 4) /* Export to ETM */
+#define ARMV7_PMNC_DP		(1 << 5) /* Disable CCNT if non-invasive debug*/
+#define	ARMV7_PMNC_N_SHIFT	11	 /* Number of counters supported */
+#define	ARMV7_PMNC_N_MASK	0x1f
+#define	ARMV7_PMNC_MASK		0x3f	 /* Mask for writable bits */
+
+/*
+ * Available counters
+ */
+#define ARMV7_CNT0 		0	/* First event counter */
+#define ARMV7_CCNT 		31	/* Cycle counter */
+
+/* Perf Event to low level counters mapping */
+#define ARMV7_EVENT_CNT_TO_CNTx	(ARMV7_COUNTER0 - ARMV7_CNT0)
+
+/*
+ * CNTENS: counters enable reg
+ */
+#define ARMV7_CNTENS_P(idx)	(1 << (idx - ARMV7_EVENT_CNT_TO_CNTx))
+#define ARMV7_CNTENS_C		(1 << ARMV7_CCNT)
+
+/*
+ * CNTENC: counters disable reg
+ */
+#define ARMV7_CNTENC_P(idx)	(1 << (idx - ARMV7_EVENT_CNT_TO_CNTx))
+#define ARMV7_CNTENC_C		(1 << ARMV7_CCNT)
+
+/*
+ * INTENS: counters overflow interrupt enable reg
+ */
+#define ARMV7_INTENS_P(idx)	(1 << (idx - ARMV7_EVENT_CNT_TO_CNTx))
+#define ARMV7_INTENS_C		(1 << ARMV7_CCNT)
+
+/*
+ * INTENC: counters overflow interrupt disable reg
+ */
+#define ARMV7_INTENC_P(idx)	(1 << (idx - ARMV7_EVENT_CNT_TO_CNTx))
+#define ARMV7_INTENC_C		(1 << ARMV7_CCNT)
+
+/*
+ * EVTSEL: Event selection reg
+ */
+#define	ARMV7_EVTSEL_MASK	0x7f		/* Mask for writable bits */
+
+/*
+ * SELECT: Counter selection reg
+ */
+#define	ARMV7_SELECT_MASK	0x1f		/* Mask for writable bits */
+
+/*
+ * FLAG: counters overflow flag status reg
+ */
+#define ARMV7_FLAG_P(idx)	(1 << (idx - ARMV7_EVENT_CNT_TO_CNTx))
+#define ARMV7_FLAG_C		(1 << ARMV7_CCNT)
+#define	ARMV7_FLAG_MASK		0xffffffff	/* Mask for writable bits */
+#define	ARMV7_OVERFLOWED_MASK	ARMV7_FLAG_MASK
+
+static inline unsigned long armv7_pmnc_read(void)
+{
+	u32 val;
+	asm volatile("mrc p15, 0, %0, c9, c12, 0" : "=r"(val));
+	return val;
+}
+
+static inline void armv7_pmnc_write(unsigned long val)
+{
+	val &= ARMV7_PMNC_MASK;
+	asm volatile("mcr p15, 0, %0, c9, c12, 0" : : "r"(val));
+}
+
+static inline int armv7_pmnc_has_overflowed(unsigned long pmnc)
+{
+	return pmnc & ARMV7_OVERFLOWED_MASK;
+}
+
+static inline int armv7_pmnc_counter_has_overflowed(unsigned long pmnc,
+					enum armv7_counters counter)
+{
+	int ret;
+
+	if (counter == ARMV7_CYCLE_COUNTER)
+		ret = pmnc & ARMV7_FLAG_C;
+	else if ((counter >= ARMV7_COUNTER0) && (counter <= ARMV7_COUNTER_LAST))
+		ret = pmnc & ARMV7_FLAG_P(counter);
+	else
+		pr_err("CPU%u checking wrong counter %d overflow status\n",
+			smp_processor_id(), counter);
+
+	return ret;
+}
+
+static inline int armv7_pmnc_select_counter(unsigned int idx)
+{
+	u32 val;
+
+	if ((idx < ARMV7_COUNTER0) || (idx > ARMV7_COUNTER_LAST)) {
+		pr_err("CPU%u selecting wrong PMNC counter"
+			" %d\n", smp_processor_id(), idx);
+		return -1;
+	}
+
+	val = (idx - ARMV7_EVENT_CNT_TO_CNTx) & ARMV7_SELECT_MASK;
+	asm volatile("mcr p15, 0, %0, c9, c12, 5" : : "r" (val));
+
+	return idx;
+}
+
+static inline u32 armv7pmu_read_counter(int idx)
+{
+	unsigned long value = 0;
+
+	if (idx == ARMV7_CYCLE_COUNTER)
+		asm volatile("mrc p15, 0, %0, c9, c13, 0" : "=r" (value));
+	else if ((idx >= ARMV7_COUNTER0) && (idx <= ARMV7_COUNTER_LAST)) {
+		if (armv7_pmnc_select_counter(idx) == idx)
+			asm volatile("mrc p15, 0, %0, c9, c13, 2"
+				     : "=r" (value));
+	} else
+		pr_err("CPU%u reading wrong counter %d\n",
+			smp_processor_id(), idx);
+
+	return value;
+}
+
+static inline void armv7pmu_write_counter(int idx, u32 value)
+{
+	if (idx == ARMV7_CYCLE_COUNTER)
+		asm volatile("mcr p15, 0, %0, c9, c13, 0" : : "r" (value));
+	else if ((idx >= ARMV7_COUNTER0) && (idx <= ARMV7_COUNTER_LAST)) {
+		if (armv7_pmnc_select_counter(idx) == idx)
+			asm volatile("mcr p15, 0, %0, c9, c13, 2"
+				     : : "r" (value));
+	} else
+		pr_err("CPU%u writing wrong counter %d\n",
+			smp_processor_id(), idx);
+}
+
+static inline void armv7_pmnc_write_evtsel(unsigned int idx, u32 val)
+{
+	if (armv7_pmnc_select_counter(idx) == idx) {
+		val &= ARMV7_EVTSEL_MASK;
+		asm volatile("mcr p15, 0, %0, c9, c13, 1" : : "r" (val));
+	}
+}
+
+static inline u32 armv7_pmnc_enable_counter(unsigned int idx)
+{
+	u32 val;
+
+	if ((idx != ARMV7_CYCLE_COUNTER) &&
+	    ((idx < ARMV7_COUNTER0) || (idx > ARMV7_COUNTER_LAST))) {
+		pr_err("CPU%u enabling wrong PMNC counter"
+			" %d\n", smp_processor_id(), idx);
+		return -1;
+	}
+
+	if (idx == ARMV7_CYCLE_COUNTER)
+		val = ARMV7_CNTENS_C;
+	else
+		val = ARMV7_CNTENS_P(idx);
+
+	asm volatile("mcr p15, 0, %0, c9, c12, 1" : : "r" (val));
+
+	return idx;
+}
+
+static inline u32 armv7_pmnc_disable_counter(unsigned int idx)
+{
+	u32 val;
+
+
+	if ((idx != ARMV7_CYCLE_COUNTER) &&
+	    ((idx < ARMV7_COUNTER0) || (idx > ARMV7_COUNTER_LAST))) {
+		pr_err("CPU%u disabling wrong PMNC counter"
+			" %d\n", smp_processor_id(), idx);
+		return -1;
+	}
+
+	if (idx == ARMV7_CYCLE_COUNTER)
+		val = ARMV7_CNTENC_C;
+	else
+		val = ARMV7_CNTENC_P(idx);
+
+	asm volatile("mcr p15, 0, %0, c9, c12, 2" : : "r" (val));
+
+	return idx;
+}
+
+static inline u32 armv7_pmnc_enable_intens(unsigned int idx)
+{
+	u32 val;
+
+	if ((idx != ARMV7_CYCLE_COUNTER) &&
+	    ((idx < ARMV7_COUNTER0) || (idx > ARMV7_COUNTER_LAST))) {
+		pr_err("CPU%u enabling wrong PMNC counter"
+			" interrupt enable %d\n", smp_processor_id(), idx);
+		return -1;
+	}
+
+	if (idx == ARMV7_CYCLE_COUNTER)
+		val = ARMV7_INTENS_C;
+	else
+		val = ARMV7_INTENS_P(idx);
+
+	asm volatile("mcr p15, 0, %0, c9, c14, 1" : : "r" (val));
+
+	return idx;
+}
+
+static inline u32 armv7_pmnc_disable_intens(unsigned int idx)
+{
+	u32 val;
+
+	if ((idx != ARMV7_CYCLE_COUNTER) &&
+	    ((idx < ARMV7_COUNTER0) || (idx > ARMV7_COUNTER_LAST))) {
+		pr_err("CPU%u disabling wrong PMNC counter"
+			" interrupt enable %d\n", smp_processor_id(), idx);
+		return -1;
+	}
+
+	if (idx == ARMV7_CYCLE_COUNTER)
+		val = ARMV7_INTENC_C;
+	else
+		val = ARMV7_INTENC_P(idx);
+
+	asm volatile("mcr p15, 0, %0, c9, c14, 2" : : "r" (val));
+
+	return idx;
+}
+
+static inline u32 armv7_pmnc_getreset_flags(void)
+{
+	u32 val;
+
+	/* Read */
+	asm volatile("mrc p15, 0, %0, c9, c12, 3" : "=r" (val));
+
+	/* Write to clear flags */
+	val &= ARMV7_FLAG_MASK;
+	asm volatile("mcr p15, 0, %0, c9, c12, 3" : : "r" (val));
+
+	return val;
+}
+
+#ifdef DEBUG
+static void armv7_pmnc_dump_regs(void)
+{
+	u32 val;
+	unsigned int cnt;
+
+	printk(KERN_INFO "PMNC registers dump:\n");
+
+	asm volatile("mrc p15, 0, %0, c9, c12, 0" : "=r" (val));
+	printk(KERN_INFO "PMNC  =0x%08x\n", val);
+
+	asm volatile("mrc p15, 0, %0, c9, c12, 1" : "=r" (val));
+	printk(KERN_INFO "CNTENS=0x%08x\n", val);
+
+	asm volatile("mrc p15, 0, %0, c9, c14, 1" : "=r" (val));
+	printk(KERN_INFO "INTENS=0x%08x\n", val);
+
+	asm volatile("mrc p15, 0, %0, c9, c12, 3" : "=r" (val));
+	printk(KERN_INFO "FLAGS =0x%08x\n", val);
+
+	asm volatile("mrc p15, 0, %0, c9, c12, 5" : "=r" (val));
+	printk(KERN_INFO "SELECT=0x%08x\n", val);
+
+	asm volatile("mrc p15, 0, %0, c9, c13, 0" : "=r" (val));
+	printk(KERN_INFO "CCNT  =0x%08x\n", val);
+
+	for (cnt = ARMV7_COUNTER0; cnt < ARMV7_COUNTER_LAST; cnt++) {
+		armv7_pmnc_select_counter(cnt);
+		asm volatile("mrc p15, 0, %0, c9, c13, 2" : "=r" (val));
+		printk(KERN_INFO "CNT[%d] count =0x%08x\n",
+			cnt-ARMV7_EVENT_CNT_TO_CNTx, val);
+		asm volatile("mrc p15, 0, %0, c9, c13, 1" : "=r" (val));
+		printk(KERN_INFO "CNT[%d] evtsel=0x%08x\n",
+			cnt-ARMV7_EVENT_CNT_TO_CNTx, val);
+	}
+}
+#endif
+
+void armv7pmu_enable_event(struct hw_perf_event *hwc, int idx)
+{
+	unsigned long flags;
+
+	/*
+	 * Enable counter and interrupt, and set the counter to count
+	 * the event that we're interested in.
+	 */
+	spin_lock_irqsave(&pmu_lock, flags);
+
+	/*
+	 * Disable counter
+	 */
+	armv7_pmnc_disable_counter(idx);
+
+	/*
+	 * Set event (if destined for PMNx counters)
+	 * We don't need to set the event if it's a cycle count
+	 */
+	if (idx != ARMV7_CYCLE_COUNTER)
+		armv7_pmnc_write_evtsel(idx, hwc->config_base);
+
+	/*
+	 * Enable interrupt for this counter
+	 */
+	armv7_pmnc_enable_intens(idx);
+
+	/*
+	 * Enable counter
+	 */
+	armv7_pmnc_enable_counter(idx);
+
+	spin_unlock_irqrestore(&pmu_lock, flags);
+}
+
+static void armv7pmu_disable_event(struct hw_perf_event *hwc, int idx)
+{
+	unsigned long flags;
+
+	/*
+	 * Disable counter and interrupt
+	 */
+	spin_lock_irqsave(&pmu_lock, flags);
+
+	/*
+	 * Disable counter
+	 */
+	armv7_pmnc_disable_counter(idx);
+
+	/*
+	 * Disable interrupt for this counter
+	 */
+	armv7_pmnc_disable_intens(idx);
+
+	spin_unlock_irqrestore(&pmu_lock, flags);
+}
+
+static irqreturn_t armv7pmu_handle_irq(int irq_num, void *dev)
+{
+	unsigned long pmnc;
+	struct perf_sample_data data;
+	struct cpu_hw_events *cpuc;
+	struct pt_regs *regs;
+	int idx;
+
+	/*
+	 * Get and reset the IRQ flags
+	 */
+	pmnc = armv7_pmnc_getreset_flags();
+
+	/*
+	 * Did an overflow occur?
+	 */
+	if (!armv7_pmnc_has_overflowed(pmnc))
+		return IRQ_NONE;
+
+	/*
+	 * Handle the counter(s) overflow(s)
+	 */
+	regs = get_irq_regs();
+
+	data.addr = 0;
+
+	cpuc = &__get_cpu_var(cpu_hw_events);
+	for (idx = 0; idx <= armpmu->num_events; ++idx) {
+		struct perf_event *event = cpuc->events[idx];
+		struct hw_perf_event *hwc;
+
+		if (!test_bit(idx, cpuc->active_mask))
+			continue;
+
+		/*
+		 * We have a single interrupt for all counters. Check that
+		 * each counter has overflowed before we process it.
+		 */
+		if (!armv7_pmnc_counter_has_overflowed(pmnc, idx))
+			continue;
+
+		hwc = &event->hw;
+		armpmu_event_update(event, hwc, idx);
+		data.period = event->hw.last_period;
+		if (!armpmu_event_set_period(event, hwc, idx))
+			continue;
+
+		if (perf_event_overflow(event, 0, &data, regs))
+			armpmu->disable(hwc, idx);
+	}
+
+	/*
+	 * Handle the pending perf events.
+	 *
+	 * Note: this call *must* be run with interrupts enabled. For
+	 * platforms that can have the PMU interrupts raised as a PMI, this
+	 * will not work.
+	 */
+	perf_event_do_pending();
+
+	return IRQ_HANDLED;
+}
+
+static void armv7pmu_start(void)
+{
+	unsigned long flags;
+
+	spin_lock_irqsave(&pmu_lock, flags);
+	/* Enable all counters */
+	armv7_pmnc_write(armv7_pmnc_read() | ARMV7_PMNC_E);
+	spin_unlock_irqrestore(&pmu_lock, flags);
+}
+
+static void armv7pmu_stop(void)
+{
+	unsigned long flags;
+
+	spin_lock_irqsave(&pmu_lock, flags);
+	/* Disable all counters */
+	armv7_pmnc_write(armv7_pmnc_read() & ~ARMV7_PMNC_E);
+	spin_unlock_irqrestore(&pmu_lock, flags);
+}
+
+static inline int armv7_a8_pmu_event_map(int config)
+{
+	int mapping = armv7_a8_perf_map[config];
+	if (HW_OP_UNSUPPORTED == mapping)
+		mapping = -EOPNOTSUPP;
+	return mapping;
+}
+
+static inline int armv7_a9_pmu_event_map(int config)
+{
+	int mapping = armv7_a9_perf_map[config];
+	if (HW_OP_UNSUPPORTED == mapping)
+		mapping = -EOPNOTSUPP;
+	return mapping;
+}
+
+static u64 armv7pmu_raw_event(u64 config)
+{
+	return config & 0xff;
+}
+
+static int armv7pmu_get_event_idx(struct cpu_hw_events *cpuc,
+				  struct hw_perf_event *event)
+{
+	int idx;
+
+	/* Always place a cycle counter into the cycle counter. */
+	if (event->config_base == ARMV7_PERFCTR_CPU_CYCLES) {
+		if (test_and_set_bit(ARMV7_CYCLE_COUNTER, cpuc->used_mask))
+			return -EAGAIN;
+
+		return ARMV7_CYCLE_COUNTER;
+	} else {
+		/*
+		 * For anything other than a cycle counter, try and use
+		 * the events counters
+		 */
+		for (idx = ARMV7_COUNTER0; idx <= armpmu->num_events; ++idx) {
+			if (!test_and_set_bit(idx, cpuc->used_mask))
+				return idx;
+		}
+
+		/* The counters are all in use. */
+		return -EAGAIN;
+	}
+}
+
+static struct arm_pmu armv7pmu = {
+	.handle_irq		= armv7pmu_handle_irq,
+	.enable			= armv7pmu_enable_event,
+	.disable		= armv7pmu_disable_event,
+	.raw_event		= armv7pmu_raw_event,
+	.read_counter		= armv7pmu_read_counter,
+	.write_counter		= armv7pmu_write_counter,
+	.get_event_idx		= armv7pmu_get_event_idx,
+	.start			= armv7pmu_start,
+	.stop			= armv7pmu_stop,
+	.max_period		= (1LLU << 32) - 1,
+};
+
+static u32 __init armv7_reset_read_pmnc(void)
+{
+	u32 nb_cnt;
+
+	/* Initialize & Reset PMNC: C and P bits */
+	armv7_pmnc_write(ARMV7_PMNC_P | ARMV7_PMNC_C);
+
+	/* Read the nb of CNTx counters supported from PMNC */
+	nb_cnt = (armv7_pmnc_read() >> ARMV7_PMNC_N_SHIFT) & ARMV7_PMNC_N_MASK;
+
+	/* Add the CPU cycles counter and return */
+	return nb_cnt + 1;
+}
+
 static int __init
 init_hw_perf_events(void)
 {
@@ -1194,14 +2098,36 @@ init_hw_perf_events(void)
 				sizeof(armv6mpcore_perf_cache_map));
 		perf_max_events = armv6mpcore_pmu.num_events;
 		break;
+	case 0xC080:	/* Cortex-A8 */
+		armv7pmu.name = ARMV7_PMU_CORTEX_A8_NAME;
+		memcpy(armpmu_perf_cache_map, armv7_a8_perf_cache_map,
+				sizeof(armv7_a8_perf_cache_map));
+		armv7pmu.event_map = armv7_a8_pmu_event_map;
+		armpmu = &armv7pmu;
+
+		/* Reset PMNC and read the nb of CNTx counters supported */
+		armv7pmu.num_events = armv7_reset_read_pmnc();
+		perf_max_events	= armv7pmu.num_events;
+		break;
+	case 0xC090:	/* Cortex-A9 */
+		armv7pmu.name = ARMV7_PMU_CORTEX_A9_NAME;
+		memcpy(armpmu_perf_cache_map, armv7_a9_perf_cache_map,
+				sizeof(armv7_a9_perf_cache_map));
+		armv7pmu.event_map = armv7_a9_pmu_event_map;
+		armpmu = &armv7pmu;
+
+		/* Reset PMNC and read the nb of CNTx counters supported */
+		armv7pmu.num_events = armv7_reset_read_pmnc();
+		perf_max_events	= armv7pmu.num_events;
+		break;
 	default:
 		pr_info("no hardware support available\n");
 		perf_max_events = -1;
 	}
 
 	if (armpmu)
-		pr_info("enabled with %s PMU driver\n",
-				armpmu->name);
+		pr_info("enabled with %s PMU driver, %d counters available\n",
+				armpmu->name, armpmu->num_events);
 
 	return 0;
 }
-- 
1.6.2.5.168.g3823




머큐리얼 에러 waiting for lock on repository 해결법 (0)	2012/04/04
Linux shell 디렉토리 이동 프로그램 (0)	2012/03/30
ARMv7 Hardware Performance Counter Events (0)	2012/03/26
최초의 모바일용 듀얼코어 NVIDIA Tegra2 성능과 전력소비 (0)	2011/02/08
일드 역대 시청률 순위 (0)	2011/01/10
DCF를 MP3로 변환할 수 없는 이유 (18)	2009/11/12

머큐리얼 에러 waiting for lock on repository 해결법 (0)	2012/04/04
Linux shell 디렉토리 이동 프로그램 (0)	2012/03/30
ARMv7 Hardware Performance Counter Events (0)	2012/03/26
최초의 모바일용 듀얼코어 NVIDIA Tegra2 성능과 전력소비 (0)	2011/02/08
일드 역대 시청률 순위 (0)	2011/01/10
DCF를 MP3로 변환할 수 없는 이유 (18)	2009/11/12

머큐리얼 에러 waiting for lock on repository 해결법 (0)	2012/04/04
Linux shell 디렉토리 이동 프로그램 (0)	2012/03/30
ARMv7 Hardware Performance Counter Events (0)	2012/03/26
최초의 모바일용 듀얼코어 NVIDIA Tegra2 성능과 전력소비 (0)	2011/02/08
일드 역대 시청률 순위 (0)	2011/01/10
DCF를 MP3로 변환할 수 없는 이유 (18)	2009/11/12

내 책상에 굴러다니는 안드로이드 단말들 (0)	2012/03/16
안드로이드 에뮬레이터 부팅 로고 변경 - initlogo.rle (0)	2012/02/07
안드로이드 에뮬레이터 CPU type 변경 (0)	2012/02/07
* glibc detected * make: free(): invalid next size (fast) (0)	2012/01/31
안드로이드 read-only File System read-write 모드로 변경 (2)	2011/11/10
ARM Condition Flags and Codes (1)	2011/11/07

내 책상에 굴러다니는 안드로이드 단말들 (0)	2012/03/16
안드로이드 에뮬레이터 부팅 로고 변경 - initlogo.rle (0)	2012/02/07
안드로이드 에뮬레이터 CPU type 변경 (0)	2012/02/07
* glibc detected * make: free(): invalid next size (fast) (0)	2012/01/31
안드로이드 read-only File System read-write 모드로 변경 (2)	2011/11/10
ARM Condition Flags and Codes (1)	2011/11/07

Flag	Explanation
`N = 0`	The result is 0, which is considered positive, and so the `N` (negative) bit is set to`0`.
`Z = 1`	The result is 0, so the `Z` (zero) bit is set to `1`.
`C = 1`	We lost some data because the result did not fit into 32 bits, so the processor indicates this by setting `C` (carry) to `1`.
`V = 0`	From a two's complement signed-arithmetic viewpoint, `0xffffffff` really means`-1`, so the operation we did was really`(-1) + 1 = 0`. That operation clearly does not overflow, so `V` (overflow) is set to `0`.

Code	Meaning (for `cmp` or `subs`)	Flags Tested
`eq`	Equal.	`Z==1`
`ne`	Not equal.	`Z==0`
`cs` or `hs`	Unsigned higher or same (or carry set).	`C==1`
`cc` or `lo`	Unsigned lower (or carry clear).	`C==0`
`mi`	Negative. The mnemonic stands for "minus".	`N==1`
`pl`	Positive or zero. The mnemonic stands for "plus".	`N==0`
`vs`	Signed overflow. The mnemonic stands for "V set".	`V==1`
`vc`	No signed overflow. The mnemonic stands for "V clear".	`V==0`
`hi`	Unsigned higher.	`(C==1) && (Z==0)`
`ls`	Unsigned lower or same.	`(C==0) \|\| (Z==1)`
`ge`	Signed greater than or equal.	`N==V`
`lt`	Signed less than.	`N!=V`
`gt`	Signed greater than.	`(Z==0) && (N==V)`
`le`	Signed less than or equal.	`(Z==1) \|\| (N!=V)`
`al` (or omitted)	Always executed.	None tested.

Instruction	Description
`cmp`	Works like `subs`, but does not store the result.
`cmn`	Works like `adds`, but does not store the result.
`tst`	Works like `ands`, but does not store the result.
`teq`	Works like `eors`, but does not store the result.

[뇌를 자극하는 PHP 프로그래밍] 458페이지 (1)	2011/09/27
[뇌를자극하는 PHP프로그래밍] 3장에서 사용하는 form.php 소스코드 (0)	2011/04/26
[뇌를자극하는 PHP프로그래밍] 357페이지 (0)	2010/09/15
[뇌를자극하는 PHP프로그래밍] 306페이지 (0)	2010/09/15
[뇌를자극하는 PHP프로그래밍] 292페이지 (0)	2010/09/15
[뇌를자극하는 PHP프로그래밍] 146페이지 (2)	2010/07/27

고추장 가격의 진실은? - 할인 아닌 할인의 실체 (0)	2011/01/31
칠레산 와인 : Casillero del Diablo Carmenere (0)	2009/09/10
칠레산 와인 : 트리오 까베르네 쇼비뇽 (0)	2009/04/20

스마트폰 시장 동향 : 안드로이드폰 vs. 아이폰 승자는? (0)	2011/01/21
정부의 에너지 절약 시행 지침의 딜레마 (0)	2011/01/13
옴니아폰 SCH-M490 (0)	2009/10/15
비난받는 고대 동정받는 출교생?! (0)	2009/04/14
프리웨어의 개발과 소스 코드의 공개 (1)	2009/04/06
영화 워낭소리와 그 명암 (0)	2009/03/03

순위	시청률	제 목	주인공
1	34.30%	히어로	기무라 타쿠야, 마츠 다카코	V
1	2001	중졸 출신의 전례 없는 검사. 도쿄 지검에 새 바람이 분다. 시청률 몫을 하는 드라마.
2	32.30%	뷰티풀 라이프	기무라 타쿠야, 토키와 다카코
2	2000	미용사인 남자 주인공과 병으로 다리를 못쓰는 여자 주인공의 러브스토리
3	30.70%	러브 제너레이션	기무라 타쿠야, 마츠 다카코	V
3	1997	이름에서도 와닿는 말 그대로 러브스토리. 그 시작은 러브호텔??? (이런 응큼쟁이들)
4	30.40%	Good Luck	기무라 타쿠야, 시바사키 코우	V
4	2003	파일럿(남주)과 정비공(여주) 그리고 승무원들의 이야기. 매회 잠깐 등장하는 윤손하의 미친(?) 존재감
5	29.20%	롱 베이케이션	기무라 타쿠야, 야마구치 토모코	V
5	1996	러브 스토리. 지금은 상상하기 힘든 출연진들. 히로스에 료쿄의 어린 모습도 볼 수 있다
6	28.30%	GTO	소리미치 다카시, 마츠시마 나나코	V
6	1998
7	28.20%	한지붕아래1	에구치 요스케, 후쿠야마 마시하루, 이시다 잇세이, 사카이 노리코
7	1993
8	27.80%	고쿠센2	나카마 유키에,카메나시 카즈야,아카니시 진	V
8	2005
9	27.00%	아스나로백서	이시다 히카리, 기무라 타쿠야, 니시지마 히데토시
9	1993
10	26.70%	한지붕아래2	에구치 요스케, 후쿠야마 마시하루, 이시다 잇세이, 마츠 다카코
10	1997
11	26.10%	야마토 나데시코	마츠시마 나나코, 츠츠미 신이치
11	2000
12	25.30%	후루하타닌자부로2	타무라 마사카즈, 니시무라 마사히코, 각회게스트
12	1996
13	25.10%	잠자는 숲	기무라 타쿠야, 나카야마 미호
13	1998
13	25.10%	후루하타닌자부로3	타무라 마사카즈, 니시무라 마사히코, 각회게스트
13	1999
15	24.90%	프라이드	기무라 타쿠야, 다케우치 유코	V
15	2004
16	24.20%	오야지	오카다 준이치, 히로스에 료코
16	2000
17	23.90%	김전일소년사건부1	도모토 쯔요시, 토모사카 리에, 후루오야 마사토
17	1995
17	23.90%	협주곡	타무라 마사카즈, 기무라 타쿠야, 미야자와 리에
17	1996
17	23.90%	화려한일족	기무라 타쿠야, 키타오오지 킨야, 야마모토 코지, 스즈키 쿄카	V
17	2007
20	23.70%	하얀거탑	카라사와 토시아키,에구치 요스케	V
20	2004
20	23.70%	비치 보이즈	타케노우치 유타카,소리미치 다카시
20	1997
22	23.60%	101번째 프로포즈	아사노 아츠코, 다케다 테츠야, 에구치 요스케	V
22	1991
23	23.40%	퓨어	와쿠이 에미, 츠츠미 신이치, 타카하시 카츠노리
23	1996
24	22.90%	이 세상의 끝	스즈키 호나미, 미카미 히로시, 토요카와 에츠시
24	1994
24	22.90%	도쿄 러브스토리	스즈키 호나미, 오다 유지, 에구치 요스케
24	1991
26	22.80%	서유기	카토리 싱고, 후카츠 에리, 이토 아츠시
26	2006
27	22.50%	신이시여 조금만 더	카네시로 타케시, 후카다 쿄코
27	1998
27	22.50%	김전일소년사건부2	도모토 쯔요시, 토모사카 리에, 후루오야 마사토
27	1996
27	22.50%	집 없는 아이2	아다치 유미, 도모토 코이치, 쿠사나기 쯔요시
27	1995
30	22.40%	엔진	기무라타쿠야, 코유키
30	2005
31	22.30%	하늘에서 떨어지는 일억개의 별	아카시야 산마, 기무라 타쿠야, 후카츠 에리	V
31	2002
32	22.20%	별의 금화	사카이 노리코, 타케노우치 유타카
32	2001
33	22.10%	속 별의 금화	사카이 노리코, 타케노우치 유타카
33	1996
33	22.10%	닥터 고토진료소	요시오카 히데타카, 시바사키 코우, 아오이 유우, 카케이 토시오
33	2006
35	22.00%	29세의 크리스마스	야마구치 토모코, 야나기바 토시로, 마츠시타 유키
35	1994
36	21.90%	고교교사1	사나다 히로유키, 사쿠라이 사치코, 아카이 히데카즈
36	1993
37	21.70%	꽃보다남자2	이노우에마오, 마츠모토 준, 오구리 슌, 마츠다쇼타, 아베 츠요시	V
37	2007
38	21.50%	마녀의 조건	마츠시마 나나코, 타키자와 히데야키	V
38	1999
38	21.50%	라스트 크리스마스	오다유지, 야다 아키코
38	2004
38	21.50%	쇼무네	에스미 마키코, 쿄노 코토미, 호쇼 마이
38	1998
41	21.40%	사람에게 상냥하게	카토리 싱고, 마츠오카 미츠루
41	2002
42	21.30%	사랑한다고 말해줘	토요카와 에츠시, 토키와 다카코, 야다 아키코
42	1995
43	21.10%	버진로드	와쿠이 에미, 소라마치 다카시, 다케다 테츠야
43	1997
44	21.00%	전차남	이토 미사키, 이토 아츠시, 하야미 모코미치	V
44	2005
44	21.00%	러브 스토리	나카야미 미호, 토요카와 에츠시, 카토리 싱고
44	2001
46	20.90%	성자의 행진	이시다 잇세이, 사카이 노리코
46	1998
47	20.80%	좋은 사람	쿠사나기 쯔요시, 칸노미호
47	1998
47	20.80%	깅로괴기파일～2개의 뇌를 가진 소년	도모토 코이치, 호쇼 마이, 미야케 켄
47	1996
49	20.70%	나와 그녀와 그녀가 사는길	쿠사나기 쯔요시, 코유키
49	2004
50	20.50%	돈이 없어	오다 유지, 자이젠 나오미, 이노하라 요시히코
50	1994
51	20.30%	쇼무니2	에스미 마키코, 쿄노 코토미, 호쇼마이
51	2000
52	20.20%	구명병동24시 2기	에구치 요스케, 마츠유키 야츠코
52	2001
52	20.20%	over time	소리미치 타카시, 에스미 마키코
52	1999
54	20.10%	파견의 품격	시노하라 료코, 카토 아이, 고이즈미 코타로, 오오이즈미 요	V
54	2007
54	20.10%	하얀 그림자	나카이 마사히로, 다케우치 유코, 카미카와 타카야
54	2001
54	20.10%	인생은 최고다	하마다 마사토시, 기무라 타쿠야, 이시다 유리코
54	1995
54	20.10%	미성년	이시다 잇세이, 소라마치 다카시, 카토리 싱고
54	1995
58	20.00%	구명병동24시 1기	에구치 요스케,마츠시마 나나코
58	1999
59	19.90%	링～최종장	야나기바 토시로, 나가세 토모야, 야다 아키코
59	1999
60	19.40%	모래그릇	나카이 마사히로, 마츠유키 야스코
60	2004
61	19.30%	카바치타레	토키와 다카코, 후카츠 에리
61	2001
62	19.20%	인간실격	도모토 쯔요시,도모토 코이치,사쿠라이 사치코
62	1994
63	19.10%	구명병동24시 3기	에구치 요스케, 마츠시마 나나코, 오구리 슌 슌
63	2005
64	18.90%	마이보스 마이히어로	나가세 토모야, 테고시 유야,아라가키 유이,다나카 코키
64	2006
64	18.90%	런치의 여왕	다케우치 유코, 에구치 유스케,츠마부키 사토시,야마시타 토모히사	V
64	2002
66	18.80%	노다메 칸타빌레	우에노 주리, 타마키 히로시,에이타	V
66	2006
66	18.80%	위험한 아네키	이토 미사키, 모리야마 미라이
66	2005
68	18.60%	14세의 어머니	시다 미라이, 다나카 미사코, 나마세 카츠히사, 키타무라 카즈키
68	2006
68	18.60%	닥터 고토의 진료소	요시오카 히데타카, 시바사키 코우
68	2003
70	18.40%	미녀 혹은 야수	마츠시마 나나코, 후쿠야마 마사하루
70	2003
71	18.20%	브라더즈	나카이 마사히로,키무라 요시노
71	1998
71	18.20%	춤추는 대수사선	오다유지, 후카츠 에리	V
71	1997
73	18.00%	Summer Snow	도모토 쯔요시, 히로스에 료코,	V
73	2000
74	17.70%	안티크～서양골동양과자점	타키자와 히데아키, 시이나 캇페이, 후지키 나오히토	V
74	2001
75	17.40%	고쿠센1	나카마 유키에,마츠모토 준, 오구리 슌	V
75	2002
76	17.30%	프로포즈 대작전	야마시타 토모히사, 나가사와 마사미, 에이쿠라 나나, 히라오카 유타	V
76	2007
76	17.30%	신선조	카토리 싱고, 야마모토 코지, 후지와라 타츠야
76	2004
78	17.20%	오렌지 데이즈	츠마부키 사토시, 시바사키 코우, 나리미야 히로키	V
78	2004
79	16.90%	결혼 못하는 남자	아베 히로시, 나츠카와 유이, 쿠니나카 료코, 츠카모토 타카시	V
79	2006
79	16.90%	노부타를 프로듀스	호리키타 마키, 카메나시 카즈야, 야마시타 토모히사	V
79	2005
79	16.90%	여왕의 교실	아마미 유키, 하라 사치에, 시다 미라이, 후쿠다마 유코	V
79	2005
79	16.90%	사랑스런 그대에게	칸노 미호, 후지키 나오히토, 이토 미사키, 타마키 히로시
79	2004
83	16.80%	태양은 지지않는다	타키자와 히데아키, 마츠유키 야스코, 유카
83	2000
84	16.40%	어텐션 플리즈	우에토 아야, 니시키도 료, 후에키 유코, 유민, 아이부 사키
84	2006
84	16.40%	드래곤 사쿠라	아베 히로시, 야마시타 토모히사, 나기사와 마사미
84	2005
86	16.30%	롱 러브레터～포류교실	토키와 다카코, 쿠보즈카 요스케, 야마시타 토모히사	V
86	2002
87	15.90%	세상의 중심에서 사랑을 외치다	야마다 타카유키, 아야세 하루카	V
87	2004
88	15.70%	쿠로사기(검은사기)	야마시타 토모히사, 호리키타 마키, 이치카와 유이, 아이카와 쇼	V
88	2006
88	15.70%	모토카레	도모토 쯔요시, 히로스에 료코, 우치야마 리나
88	2003
90	15.60%	아네고	시노하라 료코, 토모사카 리에, 아카니시 진
90	2005
91	15.30%	1리터의 눈물	사와지리 에리카, 니시키도 료, 후지키 나오히토	V
91	2005
91	15.30%	데릴사위	나가세 토모야, 다케우치 유코, 아이바 마사키
91	2001

오탈자와 새 교정판 (8)	2010/09/15
라면 받침대로 쓰기에... (0)	2009/11/13
책 오탈자 찾기 후 (2)	2009/11/13
[책 출간] 뇌를 자극하는 PHP 프로그래밍 (6)	2009/07/30

필 드	필드명	데이터 형	크기	비 고
학생번호	student_id	INT		학생 테이블의 키
이름	Name	VARCHAR	10
학년	Grade	TYNYINT
학과번호	dept_no	INT		학과 테이블의 키

[ASPLOS 2009] DFTL (0)	2010/07/27
[ASPLOS 2010] SherLog: error diagnosis by connecting clues from run-time logs (0)	2010/07/23
PCM (Phase Change Memory, or PRAM) (3)	2010/03/09

이상한 나라의 행복한 브라운

공개 강연 일정 및 수강 신청 방법

'책' 카테고리의 다른 글

머큐리얼 에러 waiting for lock on repository 해결법

'잡다한 이야기 > 토막 정보' 카테고리의 다른 글

Linux shell 디렉토리 이동 프로그램

'잡다한 이야기 > 토막 정보' 카테고리의 다른 글

ARMv7 Hardware Performance Counter Events

[PATCH 5/5] arm/perfevents: implement perf event support for ARMv6

'잡다한 이야기 > 토막 정보' 카테고리의 다른 글

내 책상에 굴러다니는 안드로이드 단말들

'프로그래밍 > 안드로이드' 카테고리의 다른 글

안드로이드 에뮬레이터 부팅 로고 변경 - initlogo.rle

'프로그래밍 > 안드로이드' 카테고리의 다른 글

안드로이드 에뮬레이터 CPU type 변경

'프로그래밍 > 안드로이드' 카테고리의 다른 글

*** glibc detected *** make: free(): invalid next size (fast)

'프로그래밍 > 안드로이드' 카테고리의 다른 글

[뇌를자극하는 PHP프로그래밍] 소스코드 (2011년 11월 15일)

'책 > 최종 소스 코드' 카테고리의 다른 글

안드로이드 read-only File System read-write 모드로 변경

Mount a filesystem read-write

'프로그래밍 > 안드로이드' 카테고리의 다른 글

ARM Condition Flags and Codes

A Realistic Example

Condition-Code Analysis Tool

The Flags

N: Negative

Z: Zero

C: Carry (or Unsigned Overflow)

V: (Signed) Overflow

Flag-Setting Example

Reading the Flags

Dedicated Comparison Instructions

End Note

Other Related Blogs

'프로그래밍 > 안드로이드' 카테고리의 다른 글

ARM Instruction Set Architecture

ARM® Instruction Set Quick Reference Card

'프로그래밍 > 안드로이드' 카테고리의 다른 글

안드로이드 에뮬레이터에서 asm 출력

'프로그래밍 > 안드로이드' 카테고리의 다른 글

[뇌를 자극하는 PHP 프로그래밍] 458페이지

'책 > 바로잡습니다' 카테고리의 다른 글

[뇌를자극하는 PHP프로그래밍] 3장에서 사용하는 form.php 소스코드

'책 > 바로잡습니다' 카테고리의 다른 글

최초의 모바일용 듀얼코어 NVIDIA Tegra2 성능과 전력소비

'잡다한 이야기 > 토막 정보' 카테고리의 다른 글

고추장 가격의 진실은? - 할인 아닌 할인의 실체

'잡다한 이야기 > 음식 이야기' 카테고리의 다른 글

스마트폰 시장 동향 : 안드로이드폰 vs. 아이폰 승자는?

'잡다한 이야기' 카테고리의 다른 글

정부의 에너지 절약 시행 지침의 딜레마

'잡다한 이야기' 카테고리의 다른 글

일드 역대 시청률 순위

'잡다한 이야기 > 토막 정보' 카테고리의 다른 글

오탈자와 새 교정판

'책 > 책 이야기' 카테고리의 다른 글

[뇌를자극하는 PHP프로그래밍] 357페이지

'책 > 바로잡습니다' 카테고리의 다른 글

[뇌를자극하는 PHP프로그래밍] 306페이지

'책 > 바로잡습니다' 카테고리의 다른 글

[뇌를자극하는 PHP프로그래밍] 292페이지

'책 > 바로잡습니다' 카테고리의 다른 글

[뇌를자극하는 PHP프로그래밍] 146페이지

'책 > 바로잡습니다' 카테고리의 다른 글

[ASPLOS 2009] DFTL

'논문 정리' 카테고리의 다른 글

[ASPLOS 2010] SherLog: error diagnosis by connecting clues from run-time logs

'논문 정리' 카테고리의 다른 글

짱구 녹음기 v1.1 - MP3 녹음기

'프로그래밍 > MP3 녹음기' 카테고리의 다른 글

뇌를 자극하는 PHP 프로그래밍 - 1장 발표자료 - pdf 파일

'책 > 동영상 강좌' 카테고리의 다른 글

PCM (Phase Change Memory, or PRAM)

'논문 정리' 카테고리의 다른 글

* glibc detected * make: free(): invalid next size (fast)

`N`: Negative

`Z`: Zero

`C`: Carry (or Unsigned Overflow)

`V`: (Signed) Overflow