// Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).
// All rights reserved.
// This component and the accompanying materials are made available
// under the terms of the License "Eclipse Public License v1.0"
// which accompanies this distribution, and is available
// at the URL "http://www.eclipse.org/legal/epl-v10.html".
//
// Initial Contributors:
// Nokia Corporation - initial contribution.
//
// Contributors:
//
// Description:
// e32test\nkernsa\benchmark.cpp
// 
//

#include <nktest/nkutils.h>

typedef void (*PFV)(void);

#ifdef __MARM__
extern "C" TUint32 __get_static_data();
extern "C" TUint32 __get_rwno_tid();
extern "C" TUint32 __cpu_id();
extern "C" TUint32 __trace_cpu_num();
#ifdef __SMP__
extern "C" TUint32 __get_local_timer_address();
extern "C" TUint32 __get_local_timer_count();
extern "C" TUint32 __set_local_timer_count();
extern "C" TUint32 __swp_local_timer_count();

void DoWatchdogTimerTest();
#endif
#endif

TUint32 Threshold;
TUint32 PsPerTick;

TUint32 Counter;
#ifdef __SMP__
TSpinLock SL1(TSpinLock::EOrderGenericIrqLow0);
TSpinLock SL2(TSpinLock::EOrderGenericPreLow0);
#endif

NThread* PingPongThread;
NFastSemaphore PingPongExitSem;
void PingPong(TAny* aPtr)
	{
	NThread* t = (NThread*)aPtr;
	FOREVER
		{
		NKern::WaitForAnyRequest();
		if (t)
			NKern::ThreadRequestSignal(t);
		}
	}

void SetupPingPongThread(TInt aPri, TInt aCpu, TBool aReply=TRUE)
	{
	NThread* t = NKern::CurrentThread();
	NKern::FSSetOwner(&PingPongExitSem, t);
	PingPongThread = CreateThreadSignalOnExit("PingPong", &PingPong, aPri, aReply?t:0, 0, -1, &PingPongExitSem, aCpu);
	}

void DestroyPingPongThread()
	{
	NKern::ThreadKill(PingPongThread);
	NKern::FSWait(&PingPongExitSem);
	}

extern "C" void dummy()
	{
	}

extern "C" void sleep1()
	{
	NKern::Sleep(1);
	}

extern "C" void do_atomic_add_rlx32()
	{
	__e32_atomic_add_rlx32(&Counter, 1);
	}

extern "C" void do_atomic_add_rel32()
	{
	__e32_atomic_add_rel32(&Counter, 1);
	}

extern "C" void do_atomic_add_acq32()
	{
	__e32_atomic_add_acq32(&Counter, 1);
	}

extern "C" void do_atomic_add_ord32()
	{
	__e32_atomic_add_ord32(&Counter, 1);
	}

extern "C" void dis_ena_int()
	{
	TInt irq = NKern::DisableAllInterrupts();
	NKern::RestoreInterrupts(irq);
	}

extern "C" void dis_ena_preempt()
	{
	NKern::Lock();
	NKern::Unlock();
	}

#ifdef __SMP__
extern "C" void sl1_lock_unlock_irq()
	{
	SL1.LockIrq();
	SL1.UnlockIrq();
	}

extern "C" void sl1_lock_unlock_irq_save()
	{
	TInt irq = SL1.LockIrqSave();
	SL1.UnlockIrqRestore(irq);
	}

extern "C" void sl1_lock_unlock_only()
	{
	TInt irq = NKern::DisableAllInterrupts();
	SL1.LockOnly();
	SL1.UnlockOnly();
	NKern::RestoreInterrupts(irq);
	}

extern "C" void sl2_lock_unlock_only()
	{
	NKern::Lock();
	SL2.LockOnly();
	SL2.UnlockOnly();
	NKern::Unlock();
	}
#endif

extern "C" void lock_unlock_system()
	{
	NKern::LockSystem();
	NKern::UnlockSystem();
	}

extern "C" void enter_leave_cs()
	{
	NKern::ThreadEnterCS();
	NKern::ThreadLeaveCS();
	}

extern "C" void resched_to_same()
	{
	NKern::Lock();
	RescheduleNeeded();
	NKern::Unlock();
	}

#ifdef __SMP__
extern "C" void get_timestamp()
	{
	NKern::Timestamp();
	}
#endif

NFastSemaphore Sem;

extern "C" void sem_signal()
	{
	NKern::FSSignal(&Sem);
	}

extern "C" void sem_signal_wait()
	{
	NKern::FSSignal(&Sem);
	NKern::FSWait(&Sem);
	}

TDfcQue* DfcQ;
TDfc* Dfc;

void BenchmarkDfcFn(TAny* aPtr)
	{
	NThread* t = (NThread*)aPtr;
	if (t)
		NKern::ThreadRequestSignal(t);
	}

void BenchmarkIDfcFn(TAny* aPtr)
	{
	NThread* t = (NThread*)aPtr;
	if (t)
		t->RequestSignal();
	}

void SetupBenchmarkDfcQ(TInt aPri, TInt aCpu, TBool aReply=TRUE)
	{
	NThread* t = NKern::CurrentThread();
	if (aPri>=0)
		{
		DfcQ = CreateDfcQ("Benchmark", aPri, (TUint32)aCpu);
		Dfc = new TDfc(&BenchmarkDfcFn, aReply?t:0, DfcQ, 1);
		}
	else
		Dfc = new TDfc(&BenchmarkIDfcFn, aReply?t:0);
	}

void DestroyBenchmarkDfcQ()
	{
	Dfc->Cancel();
	delete Dfc;
	if (DfcQ)
		DestroyDfcQ(DfcQ);
	Dfc = 0;
	DfcQ = 0;
	}




TUint32 Ps(TUint64 x)
	{
	x*=PsPerTick;
	if (x>>32)
		return KMaxTUint32;
	return (TUint32)x;
	}

TUint64 Iterate(PFV f, TUint32 aCount)
	{
	TUint64 initial = fast_counter();
	do	{
		(*f)();
		--aCount;
		} while(aCount);
	TUint64 final = fast_counter();
	return final - initial;
	}

TUint32 Measure(PFV f)
	{
	TUint32 n = 1;
	TUint64 time;
	do	{
		n<<=1;
		time = Iterate(f, n);
		} while(time < Threshold);
	time *= PsPerTick;
	time /= n;
	if (time >> 32)
		return KMaxTUint32;
	return (TUint32)time;
	}

void ping_pong_threads()
	{
	NKern::ThreadRequestSignal(PingPongThread);
	NKern::WaitForAnyRequest();
	}

void ping_pong_threads_nr()
	{
	NKern::ThreadRequestSignal(PingPongThread);
	}

TUint32 DoPingPongTest(TInt aPri, TInt aCpu, TBool aReply=TRUE)
	{
	SetupPingPongThread(aPri, aCpu, aReply);
	TUint32 x;
	if (aReply)
		x = Measure(&ping_pong_threads);
	else
		x = Measure(&ping_pong_threads_nr);
	DestroyPingPongThread();
	TEST_PRINT4("PingPong: Pri %2d Cpu %2d Reply %1d -> %ups", aPri, aCpu, aReply, x);
	return x;
	}

void do_dfc_test()
	{
	Dfc->Enque();
	NKern::WaitForAnyRequest();
	}

void do_dfc_test_nr()
	{
	Dfc->Enque();
	}

void do_idfc_test()
	{
	NKern::Lock();
	Dfc->Add();
	NKern::Unlock();
	NKern::WaitForAnyRequest();
	}

void do_idfc_test_nr()
	{
	NKern::Lock();
	Dfc->Add();
	NKern::Unlock();
	}

TUint32 DoDfcTest(TInt aPri, TInt aCpu, TBool aReply=TRUE)
	{
	SetupBenchmarkDfcQ(aPri, aCpu, aReply);
	TUint32 x;
	PFV f = aReply ? (aPri<0 ? &do_idfc_test : &do_dfc_test) : (aPri<0 ? &do_idfc_test_nr : &do_dfc_test_nr);
	x = Measure(f);
	DestroyBenchmarkDfcQ();
	TEST_PRINT4("Dfc: Pri %2d Cpu %2d Reply %1d -> %ups", aPri, aCpu, aReply, x);
	return x;
	}

void BenchmarkTests()
	{
	TUint64 fcf = fast_counter_freq();
	Threshold = (TUint32)fcf;
	if (Threshold > 10000000u)
		Threshold /= 10u;
	else if (Threshold > 1000000u)
		Threshold = 1000000u;
	TUint64 ps_per_tick = UI64LIT(1000000000000);
	ps_per_tick /= fcf;
	PsPerTick = (TUint32)ps_per_tick;
	TEST_PRINT1("Threshold %u", Threshold);
	TEST_PRINT1("PsPerTick %u", PsPerTick);

	TUint32 dummy_time = Measure(&dummy);
	TEST_PRINT1("Dummy %ups", dummy_time);

	TUint32 dmb_time = Measure(&__e32_memory_barrier);
	TEST_PRINT1("DMB loop %ups", dmb_time);
	dmb_time -= dummy_time;
	TEST_PRINT1("DMB %ups", dmb_time);

	TUint32 dsb_time = Measure(&__e32_io_completion_barrier);
	TEST_PRINT1("DSB loop %ups", dsb_time);
	dsb_time -= dummy_time;
	TEST_PRINT1("DSB %ups", dsb_time);

#ifdef __SMP__
	TUint32 timestamp_time = Measure(&get_timestamp) - dummy_time;
	TEST_PRINT1("NKern::Timestamp() %ups", timestamp_time);
#endif

	TUint32 ps;
	ps = Measure(&sleep1);
	TEST_PRINT1("Sleep(1) %ups", ps-dummy_time);
	ps = Measure(&do_atomic_add_rlx32);
	TEST_PRINT1("atomic_add_rlx32 %ups", ps-dummy_time);
	ps = Measure(&do_atomic_add_acq32);
	TEST_PRINT1("atomic_add_acq32 %ups", ps-dummy_time);
	ps = Measure(&do_atomic_add_rel32);
	TEST_PRINT1("atomic_add_rel32 %ups", ps-dummy_time);
	ps = Measure(&do_atomic_add_ord32);
	TEST_PRINT1("atomic_add_ord32 %ups", ps-dummy_time);

	TUint32 dis_ena_int_time = Measure(&dis_ena_int) - dummy_time;
	TEST_PRINT1("dis_ena_int %ups", dis_ena_int_time);

	TUint32 dis_ena_preempt_time = Measure(&dis_ena_preempt) - dummy_time;
	TEST_PRINT1("dis_ena_preempt %ups", dis_ena_preempt_time);

#ifdef __SMP__
	TUint32 sl1_irq_time = Measure(&sl1_lock_unlock_irq) - dummy_time;
	TEST_PRINT1("sl1_irq_time %ups", sl1_irq_time);

	TUint32 sl1_irqsave_time = Measure(&sl1_lock_unlock_irq_save) - dummy_time;
	TEST_PRINT1("sl1_irqsave_time %ups", sl1_irqsave_time);

	TUint32 sl1_only_time = Measure(&sl1_lock_unlock_only) - dis_ena_int_time - dummy_time;
	TEST_PRINT1("sl1_only_time %ups", sl1_only_time);

	TUint32 sl2_only_time = Measure(&sl2_lock_unlock_only) - dis_ena_preempt_time - dummy_time;
	TEST_PRINT1("sl2_only_time %ups", sl2_only_time);
#endif

	TUint32 lock_unlock_system_time = Measure(&lock_unlock_system) - dummy_time;
	TEST_PRINT1("lock_unlock_system_time %ups", lock_unlock_system_time);

	TUint32 enter_leave_cs_time = Measure(&enter_leave_cs) - dummy_time;
	TEST_PRINT1("enter_leave_cs_time %ups", enter_leave_cs_time);

	TUint32 resched_to_same_time = Measure(&resched_to_same) - dummy_time;
	TEST_PRINT1("resched_to_same_time %ups", resched_to_same_time);

#ifdef __MARM__
	TUint32 get_static_data_time = Measure((PFV)&__get_static_data) - dummy_time;
	TEST_PRINT1("get_static_data_time %ups", get_static_data_time);

	TUint32 get_sp_time = Measure((PFV)&__stack_pointer) - dummy_time;
	TEST_PRINT1("get_sp_time %ups", get_sp_time);

	TUint32 get_cpsr_time = Measure((PFV)&__cpu_status_reg) - dummy_time;
	TEST_PRINT1("get_cpsr_time %ups", get_cpsr_time);

#ifdef __SMP__
	TUint32 get_cpu_id_time = Measure((PFV)&__cpu_id) - dummy_time;
	TEST_PRINT1("get_cpu_id_time %ups", get_cpu_id_time);

	TUint32 trace_cpu_num_time = Measure((PFV)&__trace_cpu_num) - dummy_time;
	TEST_PRINT1("trace_cpu_num_time %ups", trace_cpu_num_time);

	TUint32 get_rwno_tid_time = Measure((PFV)&__get_rwno_tid) - dummy_time;
	TEST_PRINT1("get_rwno_tid_time %ups", get_rwno_tid_time);

	TUint32 get_lta_time = Measure((PFV)&__get_local_timer_address) - dummy_time;
	TEST_PRINT1("get_local_timer_address %ups", get_lta_time);

	TUint32 get_ltc_time = Measure((PFV)&__get_local_timer_count) - dummy_time;
	TEST_PRINT1("get_local_timer_count %ups", get_ltc_time);

	TUint32 set_ltc_time = Measure((PFV)&__set_local_timer_count) - dummy_time;
	TEST_PRINT1("set_local_timer_count %ups", set_ltc_time);

	TUint32 swp_ltc_time = Measure((PFV)&__swp_local_timer_count) - dummy_time;
	TEST_PRINT1("swp_local_timer_count %ups", swp_ltc_time);
#endif

	TUint32 get_current_thread_time = Measure((PFV)&NKern::CurrentThread) - dummy_time;
	TEST_PRINT1("get_current_thread_time %ups", get_current_thread_time);

#ifdef __SMP__
	TUint32 get_current_threadL_time = Measure((PFV)&NCurrentThreadL) - dummy_time;
	TEST_PRINT1("get_current_threadL_time %ups", get_current_threadL_time);
#endif
#endif

	NThread* t = NKern::CurrentThread();
	NKern::FSSetOwner(&Sem, t);

	TUint32 sem_signal_time = Measure(&sem_signal) - dummy_time;
	TEST_PRINT1("sem_signal_time %ups", sem_signal_time);

	new (&Sem) NFastSemaphore(t);

	TUint32 sem_signal_wait_time = Measure(&sem_signal_wait) - dummy_time;
	TEST_PRINT1("sem_signal_wait_time %ups", sem_signal_wait_time);

	DoPingPongTest(31, 0);
	DoPingPongTest(11, 0);
	DoPingPongTest(31, 1);
	DoPingPongTest(11, 1);
	DoPingPongTest(31, -1);
	DoPingPongTest(11, -1);
	DoPingPongTest(31, 0, FALSE);

	DoDfcTest(31, 0);
	DoDfcTest(11, 0);
	DoDfcTest(31, 1);
	DoDfcTest(11, 1);
	DoDfcTest(31, -1);
	DoDfcTest(11, -1);
	DoDfcTest(31, 0, FALSE);
	DoDfcTest(-1, 0, TRUE);
	DoDfcTest(-1, 0, FALSE);
#if defined(__MARM__) && defined(__SMP__)
	DoWatchdogTimerTest();
#endif
	}