tests: Add test for mem-acc infrastructure

Test mem-acc mapper, accessors and caching

Signed-off-by: Mike Leach <mike.leach@linaro.org>

6 files changed, 1072 insertions, 0 deletions

diff --git a/decoder/build/linux/makefile b/decoder/build/linux/makefile
index 1f042da5d3fd..b222e43ad724 100644
--- a/decoder/build/linux/makefile
+++ b/decoder/build/linux/makefile
@@ -175,6 +175,7 @@ tests: libs
 	cd $(OCSD_ROOT)/tests/build/linux/mem_buffer_eg && $(MAKE)
 	cd $(OCSD_ROOT)/tests/build/linux/frame_demux_test && $(MAKE)
 	cd $(OCSD_ROOT)/tests/build/linux/perr && $(MAKE)
+	cd $(OCSD_ROOT)/tests/build/linux/mem_acc_test && $(MAKE)
 
 #
 # build docs
diff --git a/decoder/build/win-vs2022/ref_trace_decode_lib/ref_trace_decode_lib.sln b/decoder/build/win-vs2022/ref_trace_decode_lib/ref_trace_decode_lib.sln
index 287ac1b81e30..6cd686d173ae 100644
--- a/decoder/build/win-vs2022/ref_trace_decode_lib/ref_trace_decode_lib.sln
+++ b/decoder/build/win-vs2022/ref_trace_decode_lib/ref_trace_decode_lib.sln
@@ -37,6 +37,11 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "perr", "..\..\..\tests\buil
 		{7F500891-CC76-405F-933F-F682BC39F923} = {7F500891-CC76-405F-933F-F682BC39F923}
 	EndProjectSection
 EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "mem-acc-test", "..\..\..\tests\build\win-vs2022\mem-acc-test\mem-acc-test.vcxproj", "{FF4F9135-DD70-4698-9B8F-0451CEA3CA44}"
+	ProjectSection(ProjectDependencies) = postProject
+		{7F500891-CC76-405F-933F-F682BC39F923} = {7F500891-CC76-405F-933F-F682BC39F923}
+	EndProjectSection
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Win32 = Debug|Win32
@@ -177,6 +182,22 @@ Global
 		{3D1E409D-5F4B-4B47-8513-A622639A5399}.Release-dll|Win32.Build.0 = Release|Win32
 		{3D1E409D-5F4B-4B47-8513-A622639A5399}.Release-dll|x64.ActiveCfg = Release|x64
 		{3D1E409D-5F4B-4B47-8513-A622639A5399}.Release-dll|x64.Build.0 = Release|x64
+		{FF4F9135-DD70-4698-9B8F-0451CEA3CA44}.Debug|Win32.ActiveCfg = Debug|Win32
+		{FF4F9135-DD70-4698-9B8F-0451CEA3CA44}.Debug|Win32.Build.0 = Debug|Win32
+		{FF4F9135-DD70-4698-9B8F-0451CEA3CA44}.Debug|x64.ActiveCfg = Debug|x64
+		{FF4F9135-DD70-4698-9B8F-0451CEA3CA44}.Debug|x64.Build.0 = Debug|x64
+		{FF4F9135-DD70-4698-9B8F-0451CEA3CA44}.Debug-dll|Win32.ActiveCfg = Debug|Win32
+		{FF4F9135-DD70-4698-9B8F-0451CEA3CA44}.Debug-dll|Win32.Build.0 = Debug|Win32
+		{FF4F9135-DD70-4698-9B8F-0451CEA3CA44}.Debug-dll|x64.ActiveCfg = Debug|x64
+		{FF4F9135-DD70-4698-9B8F-0451CEA3CA44}.Debug-dll|x64.Build.0 = Debug|x64
+		{FF4F9135-DD70-4698-9B8F-0451CEA3CA44}.Release|Win32.ActiveCfg = Release|Win32
+		{FF4F9135-DD70-4698-9B8F-0451CEA3CA44}.Release|Win32.Build.0 = Release|Win32
+		{FF4F9135-DD70-4698-9B8F-0451CEA3CA44}.Release|x64.ActiveCfg = Release|x64
+		{FF4F9135-DD70-4698-9B8F-0451CEA3CA44}.Release|x64.Build.0 = Release|x64
+		{FF4F9135-DD70-4698-9B8F-0451CEA3CA44}.Release-dll|Win32.ActiveCfg = Release|Win32
+		{FF4F9135-DD70-4698-9B8F-0451CEA3CA44}.Release-dll|Win32.Build.0 = Release|Win32
+		{FF4F9135-DD70-4698-9B8F-0451CEA3CA44}.Release-dll|x64.ActiveCfg = Release|x64
+		{FF4F9135-DD70-4698-9B8F-0451CEA3CA44}.Release-dll|x64.Build.0 = Release|x64
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
diff --git a/decoder/tests/build/linux/mem_acc_test/makefile b/decoder/tests/build/linux/mem_acc_test/makefile
new file mode 100644
index 000000000000..10df021024c0
--- /dev/null
+++ b/decoder/tests/build/linux/mem_acc_test/makefile
@@ -0,0 +1,88 @@
+########################################################
+# Copyright 2022 ARM Limited. All rights reserved.
+# 
+# Redistribution and use in source and binary forms, with or without modification, 
+# are permitted provided that the following conditions are met:
+# 
+# 1. Redistributions of source code must retain the above copyright notice, 
+# this list of conditions and the following disclaimer.
+# 
+# 2. Redistributions in binary form must reproduce the above copyright notice, 
+# this list of conditions and the following disclaimer in the documentation 
+# and/or other materials provided with the distribution. 
+# 
+# 3. Neither the name of the copyright holder nor the names of its contributors 
+# may be used to endorse or promote products derived from this software without 
+# specific prior written permission. 
+# 
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 'AS IS' AND 
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
+# IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
+# INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND 
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+# 
+#################################################################################
+
+########
+# opencsd: makefile for the perr error lister
+#
+
+CXX := $(MASTER_CXX)
+LINKER := $(MASTER_LINKER)	
+
+PROG = mem-acc-test
+
+BUILD_DIR=./$(PLAT_DIR)
+
+VPATH	=	 $(OCSD_TESTS)/source 
+
+CXX_INCLUDES	=	\
+			-I$(OCSD_TESTS)/source \
+			-I$(OCSD_INCLUDE)
+
+OBJECTS		=	$(BUILD_DIR)/mem_acc_test.o
+
+LIBS		=	-L$(LIB_TEST_TARGET_DIR) -L$(LIB_TARGET_DIR) -l$(LIB_BASE_NAME)
+
+all: copy_libs
+
+test_app: $(BIN_TEST_TARGET_DIR)/$(PROG)
+
+
+ $(BIN_TEST_TARGET_DIR)/$(PROG): $(OBJECTS) | build_dir
+			mkdir -p  $(BIN_TEST_TARGET_DIR)
+			$(LINKER) $(LDFLAGS) $(OBJECTS) -Wl,--start-group $(LIBS) -Wl,--end-group -o $(BIN_TEST_TARGET_DIR)/$(PROG)
+
+build_dir:
+	mkdir -p $(BUILD_DIR)
+
+.PHONY: copy_libs
+copy_libs: $(BIN_TEST_TARGET_DIR)/$(PROG)
+	cp $(LIB_TARGET_DIR)/*.so* $(BIN_TEST_TARGET_DIR)/.
+
+
+
+#### build rules
+## object dependencies
+DEPS := $(OBJECTS:%.o=%.d)
+
+-include $(DEPS)
+
+## object compile
+$(BUILD_DIR)/%.o : %.cpp | build_dir
+			$(CXX) $(CXXFLAGS) $(CXX_INCLUDES) -MMD $< -o $@
+
+#### clean
+.PHONY: clean
+clean :
+	-rm $(BIN_TEST_TARGET_DIR)/$(PROG) $(OBJECTS)
+	-rm $(DEPS)
+	-rm $(BIN_TEST_TARGET_DIR)/*.so*
+	-rmdir $(BUILD_DIR)
+
+# end of file makefile
diff --git a/decoder/tests/build/win-vs2022/mem-acc-test/mem-acc-test.vcxproj b/decoder/tests/build/win-vs2022/mem-acc-test/mem-acc-test.vcxproj
new file mode 100644
index 000000000000..1c3e04a77228
--- /dev/null
+++ b/decoder/tests/build/win-vs2022/mem-acc-test/mem-acc-test.vcxproj
@@ -0,0 +1,169 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\..\..\source\mem_acc_test.cpp" />
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <VCProjectVersion>16.0</VCProjectVersion>
+    <Keyword>Win32Proj</Keyword>
+    <ProjectGuid>{ff4f9135-dd70-4698-9b8f-0451cea3ca44}</ProjectGuid>
+    <RootNamespace>memacctest</RootNamespace>
+    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v143</PlatformToolset>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v143</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v143</PlatformToolset>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v143</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="Shared">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="..\..\..\..\build\win-vs2022\opencsd.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="..\..\..\..\build\win-vs2022\opencsd.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="..\..\..\..\build\win-vs2022\opencsd.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="..\..\..\..\build\win-vs2022\opencsd.props" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <LinkIncremental>true</LinkIncremental>
+    <OutDir>..\..\..\bin\win$(PlatformArchitecture)\dbg\</OutDir>
+    <IntDir>$(Platform)\$(Configuration)\</IntDir>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <LinkIncremental>false</LinkIncremental>
+    <OutDir>..\..\..\bin\win$(PlatformArchitecture)\rel\</OutDir>
+    <IntDir>$(Platform)\$(Configuration)\</IntDir>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <LinkIncremental>true</LinkIncremental>
+    <OutDir>..\..\..\bin\win$(PlatformArchitecture)\dbg\</OutDir>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <LinkIncremental>false</LinkIncremental>
+    <OutDir>..\..\..\bin\win$(PlatformArchitecture)\rel\</OutDir>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <SDLCheck>true</SDLCheck>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ConformanceMode>true</ConformanceMode>
+      <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\snapshot_parser_lib\include</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalLibraryDirectories>..\..\..\..\lib\win$(PlatformArchitecture)\dbg\;..\..\..\..\tests\lib\win$(PlatformArchitecture)\dbg\</AdditionalLibraryDirectories>
+      <AdditionalDependencies>lib$(LIB_BASE_NAME).lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <SDLCheck>true</SDLCheck>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ConformanceMode>true</ConformanceMode>
+      <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\snapshot_parser_lib\include</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalLibraryDirectories>..\..\..\..\lib\win$(PlatformArchitecture)\rel\;..\..\..\..\tests\lib\win$(PlatformArchitecture)\rel\</AdditionalLibraryDirectories>
+      <AdditionalDependencies>lib$(LIB_BASE_NAME).lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <SDLCheck>true</SDLCheck>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ConformanceMode>true</ConformanceMode>
+      <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\snapshot_parser_lib\include</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalLibraryDirectories>..\..\..\..\lib\win$(PlatformArchitecture)\dbg\;..\..\..\..\tests\lib\win$(PlatformArchitecture)\dbg\</AdditionalLibraryDirectories>
+      <AdditionalDependencies>lib$(LIB_BASE_NAME).lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <SDLCheck>true</SDLCheck>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ConformanceMode>true</ConformanceMode>
+      <AdditionalIncludeDirectories>..\..\..\..\include;..\..\..\snapshot_parser_lib\include</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalLibraryDirectories>..\..\..\..\lib\win$(PlatformArchitecture)\rel\;..\..\..\..\tests\lib\win$(PlatformArchitecture)\rel\</AdditionalLibraryDirectories>
+      <AdditionalDependencies>lib$(LIB_BASE_NAME).lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>
\ No newline at end of file
diff --git a/decoder/tests/build/win-vs2022/mem-acc-test/mem-acc-test.vcxproj.filters b/decoder/tests/build/win-vs2022/mem-acc-test/mem-acc-test.vcxproj.filters
new file mode 100644
index 000000000000..72f701ec8ebf
--- /dev/null
+++ b/decoder/tests/build/win-vs2022/mem-acc-test/mem-acc-test.vcxproj.filters
@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="Source Files">
+      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
+      <Extensions>cpp;c;cc;cxx;c++;cppm;ixx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
+    </Filter>
+    <Filter Include="Header Files">
+      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
+      <Extensions>h;hh;hpp;hxx;h++;hm;inl;inc;ipp;xsd</Extensions>
+    </Filter>
+    <Filter Include="Resource Files">
+      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
+      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\..\..\source\mem_acc_test.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+  </ItemGroup>
+</Project>
\ No newline at end of file
diff --git a/decoder/tests/source/mem_acc_test.cpp b/decoder/tests/source/mem_acc_test.cpp
new file mode 100644
index 000000000000..80666fbc9758
--- /dev/null
+++ b/decoder/tests/source/mem_acc_test.cpp
@@ -0,0 +1,771 @@
+/*
+ * \file       mem_acc_test.cpp
+ * \brief      OpenCSD : Component tests for memory accessor and caching
+ *
+ * \copyright  Copyright (c) 2023, ARM Limited. All Rights Reserved.
+ */
+
+
+ /*
+  * Redistribution and use in source and binary forms, with or without modification,
+  * are permitted provided that the following conditions are met:
+  *
+  * 1. Redistributions of source code must retain the above copyright notice,
+  * this list of conditions and the following disclaimer.
+  *
+  * 2. Redistributions in binary form must reproduce the above copyright notice,
+  * this list of conditions and the following disclaimer in the documentation
+  * and/or other materials provided with the distribution.
+  *
+  * 3. Neither the name of the copyright holder nor the names of its contributors
+  * may be used to endorse or promote products derived from this software without
+  * specific prior written permission.
+  *
+  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 'AS IS' AND
+  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+  * IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+  */
+
+/* 
+ * Test program to validate the memory accessor and caching.
+ * 
+ * Checks for memory spaces, overlapping VA, cache sizes 
+ */
+
+#include <cstdio>
+#include <string>
+#include <iostream>
+#include <sstream>
+#include <cstring>
+
+#include "opencsd.h"  
+
+// logging
+static ocsdMsgLogger logger;
+static ocsdDefaultErrorLogger err_log;
+static ocsd_hndl_err_log_t err_log_handle;
+static int logOpts = ocsdMsgLogger::OUT_STDOUT | ocsdMsgLogger::OUT_FILE;
+static std::string logfileName = "mem_acc_test.ppl";
+
+// test pass fail counts
+static int tests_passed = 0;
+static int tests_failed = 0;
+
+// number of blocks per memory area
+#define NUM_BLOCKS 2
+// number of 32 but words in each block
+#define BLOCK_NUM_WORDS 8192
+// size of block in bytes
+#define BLOCK_SIZE_BYTES (4 * BLOCK_NUM_WORDS)
+
+// some memory areas to use for testing
+static uint32_t el01_ns_blocks[NUM_BLOCKS][BLOCK_NUM_WORDS];
+static uint32_t el2_ns_blocks[NUM_BLOCKS][BLOCK_NUM_WORDS];
+static uint32_t el01_s_blocks[NUM_BLOCKS][BLOCK_NUM_WORDS];
+static uint32_t el2_s_blocks[NUM_BLOCKS][BLOCK_NUM_WORDS];
+static uint32_t el3_blocks[NUM_BLOCKS][BLOCK_NUM_WORDS];
+static uint32_t el01_r_blocks[NUM_BLOCKS][BLOCK_NUM_WORDS];
+static uint32_t el2_r_blocks[NUM_BLOCKS][BLOCK_NUM_WORDS];
+static uint32_t el3_root_blocks[NUM_BLOCKS][BLOCK_NUM_WORDS];
+
+#define BLOCK_VAL(mem_space, block_num, index) (uint32_t)(((uint32_t)mem_space << 24) | ((uint32_t)block_num << 16) | (uint32_t)index)
+
+// memory access mapper - used for tests
+static TrcMemAccMapGlobalSpace mapper;
+
+
+
+void populate_block(const ocsd_mem_space_acc_t mem_space, uint32_t block_array[NUM_BLOCKS][BLOCK_NUM_WORDS])
+{
+    for (int i = 0; i < NUM_BLOCKS; i++) {
+        for (int j = 0; j < BLOCK_NUM_WORDS; j++)
+            block_array[i][j] = BLOCK_VAL(mem_space, i, j);
+    }
+}
+
+void populate_all_blocks()
+{
+    populate_block(OCSD_MEM_SPACE_EL1N, el01_ns_blocks);
+    populate_block(OCSD_MEM_SPACE_EL2, el2_ns_blocks);
+    populate_block(OCSD_MEM_SPACE_EL1S, el01_s_blocks);
+    populate_block(OCSD_MEM_SPACE_EL2S, el2_s_blocks);
+    populate_block(OCSD_MEM_SPACE_EL3, el3_blocks);
+    populate_block(OCSD_MEM_SPACE_EL1R, el01_r_blocks);
+    populate_block(OCSD_MEM_SPACE_EL2R, el2_r_blocks);
+    populate_block(OCSD_MEM_SPACE_ROOT, el3_root_blocks);
+}
+
+bool process_cmd_line_logger_opts(int argc, char* argv[])
+{
+    bool goodLoggerOpts = true;
+    bool bChangingOptFlags = false;
+    int newlogOpts = ocsdMsgLogger::OUT_NONE;
+    std::string opt;
+    if (argc > 1)
+    {
+        int options_to_process = argc - 1;
+        int optIdx = 1;
+        while (options_to_process > 0)
+        {
+            opt = argv[optIdx];
+            if (opt == "-logstdout")
+            {
+                newlogOpts |= ocsdMsgLogger::OUT_STDOUT;
+                bChangingOptFlags = true;
+            }
+            else if (opt == "-logstderr")
+            {
+                newlogOpts |= ocsdMsgLogger::OUT_STDERR;
+                bChangingOptFlags = true;
+            }
+            else if (opt == "-logfile")
+            {
+                newlogOpts |= ocsdMsgLogger::OUT_FILE;
+                bChangingOptFlags = true;
+            }
+            else if (opt == "-logfilename")
+            {
+                options_to_process--;
+                optIdx++;
+                if (options_to_process)
+                {
+                    logfileName = argv[optIdx];
+                    newlogOpts |= ocsdMsgLogger::OUT_FILE;
+                    bChangingOptFlags = true;
+                }
+                else
+                {
+                    goodLoggerOpts = false;
+                }
+            }
+            options_to_process--;
+            optIdx++;
+        }
+    }
+    if (bChangingOptFlags)
+        logOpts = newlogOpts;
+    return goodLoggerOpts;
+}
+
+void log_error(const ocsdError& err)
+{
+    err_log.LogError(err_log_handle, &err);
+}
+
+void log_test_start(const char* testname)
+{
+    std::ostringstream oss;
+    oss << "*** Test " << testname << " Starting.\n";
+    logger.LogMsg(oss.str());
+}
+
+void log_test_end(const char* testname, const int pass, const int fail)
+{
+    std::ostringstream oss;
+    oss << "*** Test " << testname << " complete. (Pass: " << pass << "; Fail:" << fail << ")\n";
+    logger.LogMsg(oss.str());
+}
+
+void test_overlap_regions()
+{
+    // test adding regions that overlap
+    // overlap in difference memory spaces is ok, otherwise fail
+    TrcMemAccBufPtr Acc1, Acc2, Acc3, Acc4;
+    ocsd_err_t err;
+    std::ostringstream oss;
+    int passed = 0, failed = 0;
+
+    log_test_start(__FUNCTION__);
+
+    // add single accessor
+    Acc1.initAccessor(0x0000, (const uint8_t*)&el01_ns_blocks[0], BLOCK_SIZE_BYTES);
+    Acc1.setMemSpace(OCSD_MEM_SPACE_EL1N);
+    err = mapper.AddAccessor(&Acc1, 0);
+    if (err != OCSD_OK) {
+        log_error(ocsdError(OCSD_ERR_SEV_ERROR, err, "Failed to set memory accessor"));
+        failed++;
+    }
+    else
+        passed++;
+
+    // overlapping region - same memory space.
+    Acc2.initAccessor(0x1000, (const uint8_t*)&el01_ns_blocks[1], BLOCK_SIZE_BYTES);
+    Acc2.setMemSpace(OCSD_MEM_SPACE_EL1N);
+    err = mapper.AddAccessor(&Acc2, 0);
+    if (err != OCSD_ERR_MEM_ACC_OVERLAP) {
+        oss.str("");
+        oss << "Error: expected OCSD_ERR_MEM_ACC_OVERLAP error for overlapping accessor range.\n";
+        logger.LogMsg(oss.str());
+        failed++;
+    }
+    else
+        passed++;
+
+    // non overlapping region - same memory space.
+    Acc2.setRange(0x8000, 0x8000 + BLOCK_SIZE_BYTES - 1);
+    err = mapper.AddAccessor(&Acc2, 0);
+    if (err != OCSD_OK) {
+        log_error(ocsdError(OCSD_ERR_SEV_ERROR, err, "Failed to set non overlapping memory accessor"));
+        failed++;
+    }
+    else
+        passed++;
+
+    // overlapping region - different memory space
+    Acc3.initAccessor(0x0000, (const uint8_t*)&el01_s_blocks[0], BLOCK_SIZE_BYTES);
+    Acc3.setMemSpace(OCSD_MEM_SPACE_EL1S);
+    err = mapper.AddAccessor(&Acc3, 0);
+    if (err != OCSD_OK) {
+        log_error(ocsdError(OCSD_ERR_SEV_ERROR, err, "Failed to set overlapping memory accessor in other memory space"));
+        failed++;
+    }
+    else
+        passed++;
+
+    // overlapping region - more general memory space.
+    Acc4.initAccessor(0x0000, (const uint8_t*)&el2_s_blocks[0], BLOCK_SIZE_BYTES);
+    Acc4.setMemSpace(OCSD_MEM_SPACE_S);
+    err = mapper.AddAccessor(&Acc4, 0);
+    if (err != OCSD_ERR_MEM_ACC_OVERLAP) {
+        oss.str("");
+        oss << "Error: expected OCSD_ERR_MEM_ACC_OVERLAP error for overlapping general _S accessor range.\n";
+        logger.LogMsg(oss.str());
+        failed++;
+    }
+    else
+        passed++;
+
+    // clean up mapper
+    mapper.RemoveAllAccessors();
+    tests_passed += passed;
+    tests_failed += failed;
+
+    log_test_end(__FUNCTION__, passed, failed);
+}
+/************************************************************************
+ * Test trcID specific memory regions - using callback function.         
+ * Emulates clinets such as perf where memory regions change over the 
+ * trace run as tasks switched in and out. Tests caching mechanisms in 
+ * mapper.
+ */
+typedef struct test_range {
+    ocsd_vaddr_t s_address;
+    uint32_t size;
+    const uint8_t* buffer; 
+    ocsd_mem_space_acc_t mem_space;
+    uint8_t trcID;
+} test_range_t;
+
+typedef struct test_range_array {
+    int num_ranges;
+    test_range_t* ranges;
+} test_range_array_t;
+
+#define IN_MEM_SPACE(m1, m2) (bool)(((uint32_t)m1)&((uint32_t)m2))
+
+static int AccCallbackCount = 0;
+
+uint32_t TestMemAccCB(const void* p_context, const ocsd_vaddr_t address, const ocsd_mem_space_acc_t mem_space, const uint8_t trcID, const uint32_t reqBytes, uint8_t* byteBuffer)
+{
+    test_range_array_t* ranges = (test_range_array_t*)p_context;
+    uint32_t bytes_read = 0;
+
+    for (int i = 0; i < ranges->num_ranges; i++)
+    {
+        if ( IN_MEM_SPACE(mem_space, ranges->ranges[i].mem_space) && 
+             (trcID == ranges->ranges[i].trcID)
+            ) 
+        {
+            if ( (address >= ranges->ranges[i].s_address) && 
+                 (address < (ranges->ranges[i].s_address + ranges->ranges[i].size))
+               )
+            {
+                // in range - get offset into buffer
+                uint32_t offset =  address - ranges->ranges[i].s_address;
+
+                // copy all bytes if enough left in range - otherwise what if left
+                if (ranges->ranges[i].size - offset >= reqBytes)
+                    bytes_read = reqBytes;
+                else
+                    bytes_read = ranges->ranges[i].size - offset;
+
+                memcpy(byteBuffer, &(ranges->ranges[i].buffer[offset]), bytes_read);
+                break;
+            }
+        }
+    }
+    AccCallbackCount++;
+    return bytes_read;
+}
+
+void set_test_range(test_range_t& range, ocsd_vaddr_t s_address, uint32_t size,
+                    const uint8_t* buffer, ocsd_mem_space_acc_t mem_space, uint8_t trcID)
+{
+    range.s_address = s_address;
+    range.size = size;
+    range.buffer = buffer;
+    range.mem_space = mem_space;
+    range.trcID = trcID;
+}
+
+// read value through mapper and direct from range - check value and callback happened
+// allows testing of expected caching and callback events 
+bool read_and_check_from_range(const int test_idx, const int range, test_range_array_t& ranges, const ocsd_vaddr_t byte_offset, bool callback)
+{
+    uint32_t read_val, num_bytes_read, expected_val;
+    uint8_t* p_local_buff = (uint8_t*)&read_val;
+    int PrevAccCallbackCount = AccCallbackCount;
+    ocsd_err_t err;
+    ocsd_vaddr_t read_address;
+    bool pass = true, mem_callback_occurred = false;
+    std::ostringstream oss;
+    std::string memSpaceStr;
+    ocsd_mem_space_acc_t mem_space;
+    uint8_t traceID;
+
+
+    mem_space = ranges.ranges[range].mem_space;
+    read_address = ranges.ranges[range].s_address + byte_offset;  // set address value
+    num_bytes_read = 4; // request 4 bytes
+    expected_val = *((uint32_t *)(&(ranges.ranges[range].buffer[byte_offset])));
+    traceID = ranges.ranges[range].trcID;
+    TrcMemAccessorBase::getMemAccSpaceString(memSpaceStr, mem_space);
+
+    oss << "Read Test(" << test_idx << "): Address 0x" << std::hex << std::setw(8) << std::setfill('0') << read_address << "; ";
+    oss << memSpaceStr << "; Traced ID 0x" << std::setw(2) << (uint32_t)traceID << "; ";
+    logger.LogMsg(oss.str());
+
+    err = mapper.ReadTargetMemory(read_address, ranges.ranges[range].trcID, OCSD_MEM_SPACE_EL1N, &num_bytes_read, p_local_buff);
+
+    mem_callback_occurred = (bool)(PrevAccCallbackCount != AccCallbackCount);
+    if (mem_callback_occurred)
+        oss.str("MemCB read; ");
+    else
+        oss.str("No MemCB; ");
+    logger.LogMsg(oss.str());
+    
+    if (err != OCSD_OK) {
+        oss.str("");
+        oss << "Error reading target memory\n";
+        logger.LogMsg(oss.str());
+        log_error(ocsdError(OCSD_ERR_SEV_ERROR, err, oss.str()));
+        pass = false;
+        goto exit_test;
+    }
+
+    if (num_bytes_read != 4) {
+        oss.str("");
+        oss << "Read Fail: Requested bytes not found (4 != " << num_bytes_read << ")\n";
+        logger.LogMsg(oss.str());
+        pass = false;
+        goto exit_test;
+    }
+
+    if (expected_val != read_val) {
+        oss.str("");
+        oss << "Read Fail: value read mismatch; 0x" << std::hex << read_val << " != 0x" << expected_val << "\n";
+        logger.LogMsg(oss.str());
+        pass = false;
+        goto exit_test;
+    }
+
+    if (callback && !mem_callback_occurred) {
+        oss.str("");
+        oss << "Read Fail: Expected callback to access memory\n";
+        logger.LogMsg(oss.str());
+        pass = false;
+        goto exit_test;
+    }
+
+    if (!callback && mem_callback_occurred) {
+        oss.str("");
+        oss << "Read Fail: Unexpected callback to access memory\n";
+        logger.LogMsg(oss.str());
+        pass = false;
+        goto exit_test;
+    }
+
+    if (pass) {
+        oss.str("\n");
+        logger.LogMsg(oss.str());
+    }
+
+exit_test:
+    return pass;
+}
+
+void test_trcid_cache_mem_cb()
+{
+    TrcMemAccCB CBAcc;
+    test_range_array_t ranges;
+    int passed = 0, failed = 0;
+    std::ostringstream oss;
+    ocsd_err_t err;
+    int read_test_idx = 1;
+    
+
+    log_test_start(__FUNCTION__);
+
+    // set up the ranges
+    ranges.num_ranges = 6;
+    ranges.ranges = new test_range_t[6];
+    
+    // 1st range 0x0000, EL1N, trcID 0x10 - 1st CPU
+    set_test_range(ranges.ranges[0], 0x0000, BLOCK_SIZE_BYTES, (const uint8_t*)&el01_ns_blocks[0], OCSD_MEM_SPACE_EL1N, 0x10);
+    // 2nd range 0x0000, EL1N, trcID 0x11 - 2nd cpu, same addresses, different data. 
+    set_test_range(ranges.ranges[1], 0x0000, BLOCK_SIZE_BYTES, (const uint8_t*)&el01_ns_blocks[1], OCSD_MEM_SPACE_EL1N, 0x11);
+    // 2nd range 0x8000, EL2N, trcID 0x10 - 2nd cpu, same addresses, different data. 
+    set_test_range(ranges.ranges[2], 0x8000, BLOCK_SIZE_BYTES, (const uint8_t*)&el2_ns_blocks[0], OCSD_MEM_SPACE_EL2, 0x10);
+    // 2nd range 0x10000, EL2N, trcID 0x11 - 2nd cpu, 
+    set_test_range(ranges.ranges[3], 0x10000, BLOCK_SIZE_BYTES, (const uint8_t*)&el2_ns_blocks[1], OCSD_MEM_SPACE_EL2, 0x11);
+    // 2nd range 0x0000, EL1 realm, trcID 0x10 - cpu 1 realm
+    set_test_range(ranges.ranges[4], 0x0000, BLOCK_SIZE_BYTES, (const uint8_t*)&el01_r_blocks[0], OCSD_MEM_SPACE_EL1R, 0x10);
+    // 2nd range 0x0000, EL2 realm, trcID 0x11 - 2nd cpu - realm . 
+    set_test_range(ranges.ranges[5], 0x0000, BLOCK_SIZE_BYTES, (const uint8_t*)&el2_r_blocks[0], OCSD_MEM_SPACE_EL2R, 0x11);
+
+    // add the callback to the mapper
+    CBAcc.initAccessor(0, 0xFFFFFFFF, OCSD_MEM_SPACE_ANY);
+    CBAcc.setCBIDIfFn(TestMemAccCB, (void*)&ranges);
+    err = mapper.AddAccessor(&CBAcc, 0);
+    if (err != OCSD_OK) {
+        log_error(ocsdError(OCSD_ERR_SEV_ERROR, err, "Failed to set callback memory accessor"));
+        failed++;
+        goto cleanup;
+    }
+
+    // run some tests 
+    // initial read - should callback and load cache page
+    read_and_check_from_range(read_test_idx++, 0, ranges, 0, true) ? passed++ : failed++; 
+
+    // next read - should not callback but use cache
+    read_and_check_from_range(read_test_idx++, 0, ranges, 0x10, false) ? passed++ : failed++; 
+
+    // different cpu - same address - should callback for cache load
+    read_and_check_from_range(read_test_idx++, 1, ranges, 0x10, true) ? passed++ : failed++;
+
+    // different cpu - same address - use cache
+    read_and_check_from_range(read_test_idx++, 1, ranges, 0x10, false) ? passed++ : failed++;
+
+
+    // clean up mapper
+cleanup:
+    mapper.RemoveAllAccessors();
+    tests_passed += passed;
+    tests_failed += failed;
+    delete[] ranges.ranges;
+
+    log_test_end(__FUNCTION__, passed, failed);
+}
+
+/************************************************************************
+ * Test trcID specific memory regions - using callback function.
+ * Emulates clinets such as perf where memory regions change over the
+ * trace run as tasks switched in and out. Tests caching mechanisms in
+ * mapper.
+ */
+
+#define TEST_ADDR_COMMON 0x000000
+#define TEST_ADDR_EL1N   0x008000
+#define TEST_ADDR_EL2    0x010000
+#define TEST_ADDR_EL1S   0x018000
+#define TEST_ADDR_EL2S   0x020000
+#define TEST_ADDR_EL3    0x028000
+#define TEST_ADDR_EL1R   0x030000
+#define TEST_ADDR_EL2R   0x038000
+#define TEST_ADDR_EL3R   0x040000
+
+bool read_and_check_value(ocsd_vaddr_t addr, const uint8_t* p_block_buffer, ocsd_mem_space_acc_t space)
+{
+    ocsd_err_t err;
+    uint32_t read_val, check_val, num_bytes;
+    std::ostringstream oss;
+    std::string memSpaceStr;
+
+
+    TrcMemAccessorBase::getMemAccSpaceString(memSpaceStr, space);
+    oss << "Read Test: Address 0x" << std::hex << std::setw(8) << std::setfill('0') << addr << "; ";
+    oss << std::setw(4) << std::setfill(' ') << memSpaceStr << ";" ;
+    logger.LogMsg(oss.str());
+
+
+    num_bytes = 4;
+    err = mapper.ReadTargetMemory(addr, 0, space, &num_bytes, (uint8_t*)&read_val);
+    if (err != OCSD_OK) {
+        log_error(ocsdError(OCSD_ERR_SEV_ERROR, err, "Failed to read from mapper"));
+        return false;
+    }
+
+    check_val = *((uint32_t *)p_block_buffer);
+    if (check_val != read_val)
+    {
+        oss.str("");
+        oss << "Read Fail: value read mismatch; 0x" << std::hex << read_val << " != 0x" << check_val << "\n";
+        logger.LogMsg(oss.str());
+        return false;
+    }
+
+    oss.str("");
+    oss << " [0x" << std::hex << std::setw(8) << std::setfill('0') << read_val << "]\n";
+    logger.LogMsg(oss.str());
+    return true;
+}
+
+void test_mem_spaces()
+{
+    ocsd_err_t err;
+    int passed = 0, failed = 0;
+    std::ostringstream oss;
+
+
+    log_test_start(__FUNCTION__);
+
+    // check each memory space, 8 of them, and a each block.
+    #define NUM_ACCS (NUM_BLOCKS * 8)
+    TrcMemAccBufPtr accs[NUM_ACCS];
+
+    //  set-up accessors - block 0 in each space is the same - the next will have no overlap
+    accs[0].initAccessor(TEST_ADDR_COMMON, (const uint8_t*)&el01_ns_blocks[0], BLOCK_SIZE_BYTES);
+    accs[0].setMemSpace(OCSD_MEM_SPACE_EL1N);
+    accs[1].initAccessor(TEST_ADDR_EL1N, (const uint8_t*)&el01_ns_blocks[1], BLOCK_SIZE_BYTES);
+    accs[1].setMemSpace(OCSD_MEM_SPACE_EL1N);
+
+    accs[2].initAccessor(TEST_ADDR_COMMON, (const uint8_t*)&el2_ns_blocks[0], BLOCK_SIZE_BYTES);
+    accs[2].setMemSpace(OCSD_MEM_SPACE_EL2);
+    accs[3].initAccessor(TEST_ADDR_EL2, (const uint8_t*)&el2_ns_blocks[1], BLOCK_SIZE_BYTES);
+    accs[3].setMemSpace(OCSD_MEM_SPACE_EL2);
+
+    accs[4].initAccessor(TEST_ADDR_COMMON, (const uint8_t*)&el01_s_blocks[0], BLOCK_SIZE_BYTES);
+    accs[4].setMemSpace(OCSD_MEM_SPACE_EL1S);
+    accs[5].initAccessor(TEST_ADDR_EL1S, (const uint8_t*)&el01_s_blocks[1], BLOCK_SIZE_BYTES);
+    accs[5].setMemSpace(OCSD_MEM_SPACE_EL1S);
+
+    accs[6].initAccessor(TEST_ADDR_COMMON, (const uint8_t*)&el2_s_blocks[0], BLOCK_SIZE_BYTES);
+    accs[6].setMemSpace(OCSD_MEM_SPACE_EL2S);
+    accs[7].initAccessor(TEST_ADDR_EL2S, (const uint8_t*)&el2_s_blocks[1], BLOCK_SIZE_BYTES);
+    accs[7].setMemSpace(OCSD_MEM_SPACE_EL2S);
+
+    accs[8].initAccessor(TEST_ADDR_COMMON, (const uint8_t*)&el3_blocks[0], BLOCK_SIZE_BYTES);
+    accs[8].setMemSpace(OCSD_MEM_SPACE_EL3);
+    accs[9].initAccessor(TEST_ADDR_EL3, (const uint8_t*)&el3_blocks[1], BLOCK_SIZE_BYTES);
+    accs[9].setMemSpace(OCSD_MEM_SPACE_EL3);
+
+    accs[10].initAccessor(TEST_ADDR_COMMON, (const uint8_t*)&el01_r_blocks[0], BLOCK_SIZE_BYTES);
+    accs[10].setMemSpace(OCSD_MEM_SPACE_EL1R);
+    accs[11].initAccessor(TEST_ADDR_EL1R, (const uint8_t*)&el01_r_blocks[1], BLOCK_SIZE_BYTES);
+    accs[11].setMemSpace(OCSD_MEM_SPACE_EL1R);
+
+    accs[12].initAccessor(TEST_ADDR_COMMON, (const uint8_t*)&el2_r_blocks[0], BLOCK_SIZE_BYTES);
+    accs[12].setMemSpace(OCSD_MEM_SPACE_EL2R);
+    accs[13].initAccessor(TEST_ADDR_EL2R, (const uint8_t*)&el2_r_blocks[1], BLOCK_SIZE_BYTES);
+    accs[13].setMemSpace(OCSD_MEM_SPACE_EL2R);
+
+    accs[14].initAccessor(TEST_ADDR_COMMON, (const uint8_t*)&el3_root_blocks[0], BLOCK_SIZE_BYTES);
+    accs[14].setMemSpace(OCSD_MEM_SPACE_ROOT);
+    accs[15].initAccessor(TEST_ADDR_EL3R, (const uint8_t*)&el3_root_blocks[1], BLOCK_SIZE_BYTES);
+    accs[15].setMemSpace(OCSD_MEM_SPACE_ROOT);
+
+    // add accessors to mapper.
+    for (int i = 0; i < NUM_ACCS; i++) {
+        err = mapper.AddAccessor(&accs[i], 0);
+        if (err != OCSD_OK) {
+            log_error(ocsdError(OCSD_ERR_SEV_ERROR, err, "Failed to set callback memory accessor"));
+            failed++;
+        }
+        else
+            passed++;
+    }
+
+    // test a bunch of reads - use specific space then check match if more global spaces are used.
+    oss.str("Test EL1N registered block\n");
+    logger.LogMsg(oss.str());
+    read_and_check_value(TEST_ADDR_COMMON, (const uint8_t*)&el01_ns_blocks[0], OCSD_MEM_SPACE_EL1N) ? passed++ : failed++;
+    read_and_check_value(TEST_ADDR_EL1N, (const uint8_t*)&el01_ns_blocks[1], OCSD_MEM_SPACE_EL1N) ? passed++ : failed++;
+    read_and_check_value(TEST_ADDR_EL1N, (const uint8_t*)&el01_ns_blocks[1], OCSD_MEM_SPACE_N) ? passed++ : failed++;
+    read_and_check_value(TEST_ADDR_EL1N, (const uint8_t*)&el01_ns_blocks[1], OCSD_MEM_SPACE_ANY) ? passed++ : failed++;
+
+    oss.str("Test EL1N registered block\n");
+    logger.LogMsg(oss.str());
+    read_and_check_value(TEST_ADDR_COMMON, (const uint8_t*)&el2_ns_blocks[0], OCSD_MEM_SPACE_EL2) ? passed++ : failed++;
+    read_and_check_value(TEST_ADDR_EL2, (const uint8_t*)&el2_ns_blocks[1], OCSD_MEM_SPACE_EL2) ? passed++ : failed++;
+    read_and_check_value(TEST_ADDR_EL2, (const uint8_t*)&el2_ns_blocks[1], OCSD_MEM_SPACE_N) ? passed++ : failed++;
+    read_and_check_value(TEST_ADDR_EL2, (const uint8_t*)&el2_ns_blocks[1], OCSD_MEM_SPACE_ANY) ? passed++ : failed++;
+
+    oss.str("Test EL1S registered block\n");
+    logger.LogMsg(oss.str());
+    read_and_check_value(TEST_ADDR_COMMON, (const uint8_t*)&el01_s_blocks[0], OCSD_MEM_SPACE_EL1S) ? passed++ : failed++;
+    read_and_check_value(TEST_ADDR_EL1S, (const uint8_t*)&el01_s_blocks[1], OCSD_MEM_SPACE_EL1S) ? passed++ : failed++;
+    read_and_check_value(TEST_ADDR_EL1S, (const uint8_t*)&el01_s_blocks[1], OCSD_MEM_SPACE_S) ? passed++ : failed++;
+    read_and_check_value(TEST_ADDR_EL1S, (const uint8_t*)&el01_s_blocks[1], OCSD_MEM_SPACE_ANY) ? passed++ : failed++;
+
+    oss.str("Test EL2S registered block\n");
+    logger.LogMsg(oss.str());
+    read_and_check_value(TEST_ADDR_COMMON, (const uint8_t*)&el2_s_blocks[0], OCSD_MEM_SPACE_EL2S) ? passed++ : failed++;
+    read_and_check_value(TEST_ADDR_EL2S, (const uint8_t*)&el2_s_blocks[1], OCSD_MEM_SPACE_EL2S) ? passed++ : failed++;
+    read_and_check_value(TEST_ADDR_EL2S, (const uint8_t*)&el2_s_blocks[1], OCSD_MEM_SPACE_S) ? passed++ : failed++;
+    read_and_check_value(TEST_ADDR_EL2S, (const uint8_t*)&el2_s_blocks[1], OCSD_MEM_SPACE_ANY) ? passed++ : failed++;
+
+    oss.str("Test EL3 registered block\n");
+    logger.LogMsg(oss.str());
+    read_and_check_value(TEST_ADDR_COMMON, (const uint8_t*)&el3_blocks[0], OCSD_MEM_SPACE_EL3) ? passed++ : failed++;
+    read_and_check_value(TEST_ADDR_EL3, (const uint8_t*)&el3_blocks[1], OCSD_MEM_SPACE_EL3) ? passed++ : failed++;
+    read_and_check_value(TEST_ADDR_EL3, (const uint8_t*)&el3_blocks[1], OCSD_MEM_SPACE_S) ? passed++ : failed++;
+    read_and_check_value(TEST_ADDR_EL3, (const uint8_t*)&el3_blocks[1], OCSD_MEM_SPACE_ANY) ? passed++ : failed++;
+
+    oss.str("Test EL1R registered block\n");
+    logger.LogMsg(oss.str());
+    read_and_check_value(TEST_ADDR_COMMON, (const uint8_t*)&el01_r_blocks[0], OCSD_MEM_SPACE_EL1R) ? passed++ : failed++;
+    read_and_check_value(TEST_ADDR_EL1R, (const uint8_t*)&el01_r_blocks[1], OCSD_MEM_SPACE_EL1R) ? passed++ : failed++;
+    read_and_check_value(TEST_ADDR_EL1R, (const uint8_t*)&el01_r_blocks[1], OCSD_MEM_SPACE_R) ? passed++ : failed++;
+    read_and_check_value(TEST_ADDR_EL1R, (const uint8_t*)&el01_r_blocks[1], OCSD_MEM_SPACE_ANY) ? passed++ : failed++;
+
+    oss.str("Test EL2R registered block\n");
+    logger.LogMsg(oss.str());
+    read_and_check_value(TEST_ADDR_COMMON, (const uint8_t*)&el2_r_blocks[0], OCSD_MEM_SPACE_EL2R) ? passed++ : failed++;
+    read_and_check_value(TEST_ADDR_EL2R, (const uint8_t*)&el2_r_blocks[1], OCSD_MEM_SPACE_EL2R) ? passed++ : failed++;
+    read_and_check_value(TEST_ADDR_EL2R, (const uint8_t*)&el2_r_blocks[1], OCSD_MEM_SPACE_R) ? passed++ : failed++;
+    read_and_check_value(TEST_ADDR_EL2R, (const uint8_t*)&el2_r_blocks[1], OCSD_MEM_SPACE_ANY) ? passed++ : failed++;
+
+    oss.str("Test ROOT registered block\n");
+    logger.LogMsg(oss.str());
+    read_and_check_value(TEST_ADDR_COMMON, (const uint8_t*)&el3_root_blocks[0], OCSD_MEM_SPACE_ROOT) ? passed++ : failed++;
+    read_and_check_value(TEST_ADDR_EL3R, (const uint8_t*)&el3_root_blocks[1], OCSD_MEM_SPACE_ROOT) ? passed++ : failed++;
+    read_and_check_value(TEST_ADDR_EL3R, (const uint8_t*)&el3_root_blocks[1], OCSD_MEM_SPACE_ANY) ? passed++ : failed++;
+
+    // clear for this test 
+    mapper.RemoveAllAccessors();
+
+    // test access more global from specific - set ANY, N S and R spaces
+    accs[0].initAccessor(TEST_ADDR_COMMON, (const uint8_t*)&el01_ns_blocks[0], BLOCK_SIZE_BYTES);
+    accs[0].setMemSpace(OCSD_MEM_SPACE_ANY);
+    accs[1].initAccessor(TEST_ADDR_EL1N, (const uint8_t*)&el01_ns_blocks[1], BLOCK_SIZE_BYTES);
+    accs[1].setMemSpace(OCSD_MEM_SPACE_N);
+    accs[2].initAccessor(TEST_ADDR_EL2, (const uint8_t*)&el2_ns_blocks[0], BLOCK_SIZE_BYTES);
+    accs[2].setMemSpace(OCSD_MEM_SPACE_S);
+    accs[3].initAccessor(TEST_ADDR_EL3, (const uint8_t*)&el2_ns_blocks[1], BLOCK_SIZE_BYTES);
+    accs[3].setMemSpace(OCSD_MEM_SPACE_R);
+
+    for (int i = 0; i < 4; i++) {
+        err = mapper.AddAccessor(&accs[i], 0);
+        if (err != OCSD_OK) {
+            log_error(ocsdError(OCSD_ERR_SEV_ERROR, err, "Failed to set callback memory accessor"));
+            failed++;
+        }
+        else
+            passed++;
+    }
+
+    // for ANY space should match all other spaces
+    uint32_t offset = 0;
+    oss.str("Test ANY registered block\n");
+    logger.LogMsg(oss.str());
+    read_and_check_value(TEST_ADDR_COMMON + offset, ((const uint8_t*)&el01_ns_blocks[0]) +offset, OCSD_MEM_SPACE_EL1N) ? passed++ : failed++;
+    offset += 4;
+    read_and_check_value(TEST_ADDR_COMMON + offset, ((const uint8_t*)&el01_ns_blocks[0]) + offset, OCSD_MEM_SPACE_EL2) ? passed++ : failed++;
+    offset += 4;
+    read_and_check_value(TEST_ADDR_COMMON + offset, ((const uint8_t*)&el01_ns_blocks[0]) + offset, OCSD_MEM_SPACE_EL1S) ? passed++ : failed++;
+    offset += 4;
+    read_and_check_value(TEST_ADDR_COMMON + offset, ((const uint8_t*)&el01_ns_blocks[0]) + offset, OCSD_MEM_SPACE_EL2S) ? passed++ : failed++;
+    offset += 4;
+    read_and_check_value(TEST_ADDR_COMMON + offset, ((const uint8_t*)&el01_ns_blocks[0]) + offset, OCSD_MEM_SPACE_EL3) ? passed++ : failed++;
+    offset += 4;
+    read_and_check_value(TEST_ADDR_COMMON + offset, ((const uint8_t*)&el01_ns_blocks[0]) + offset, OCSD_MEM_SPACE_EL1R) ? passed++ : failed++;
+    offset += 4;
+    read_and_check_value(TEST_ADDR_COMMON + offset, ((const uint8_t*)&el01_ns_blocks[0]) + offset, OCSD_MEM_SPACE_EL2R) ? passed++ : failed++;
+    offset += 4;
+    read_and_check_value(TEST_ADDR_COMMON + offset, ((const uint8_t*)&el01_ns_blocks[0]) + offset, OCSD_MEM_SPACE_S) ? passed++ : failed++;
+    offset += 4;
+    read_and_check_value(TEST_ADDR_COMMON + offset, ((const uint8_t*)&el01_ns_blocks[0]) + offset, OCSD_MEM_SPACE_N) ? passed++ : failed++;
+    offset += 4;
+    read_and_check_value(TEST_ADDR_COMMON + offset, ((const uint8_t*)&el01_ns_blocks[0]) + offset, OCSD_MEM_SPACE_R) ? passed++ : failed++;
+    offset += 4;
+    read_and_check_value(TEST_ADDR_COMMON + offset, ((const uint8_t*)&el01_ns_blocks[0]) + offset, OCSD_MEM_SPACE_ROOT) ? passed++ : failed++;
+
+    oss.str("Test Any N registered block\n");
+    logger.LogMsg(oss.str());
+    offset = 0;
+    read_and_check_value(TEST_ADDR_EL1N + offset, ((const uint8_t*)&el01_ns_blocks[1]) + offset, OCSD_MEM_SPACE_EL1N) ? passed++ : failed++;
+    offset += 4;
+    read_and_check_value(TEST_ADDR_EL1N + offset, ((const uint8_t*)&el01_ns_blocks[1]) + offset, OCSD_MEM_SPACE_EL2) ? passed++ : failed++;
+    offset += 4;
+    read_and_check_value(TEST_ADDR_EL1N + offset, ((const uint8_t*)&el01_ns_blocks[1]) + offset, OCSD_MEM_SPACE_N) ? passed++ : failed++;
+
+    oss.str("Test Any S registered block\n");
+    logger.LogMsg(oss.str());
+    offset = 0;
+    read_and_check_value(TEST_ADDR_EL2 + offset, ((const uint8_t*)&el2_ns_blocks[0]) + offset, OCSD_MEM_SPACE_EL1S) ? passed++ : failed++;
+    offset += 4;
+    read_and_check_value(TEST_ADDR_EL2 + offset, ((const uint8_t*)&el2_ns_blocks[0]) + offset, OCSD_MEM_SPACE_EL2S) ? passed++ : failed++;
+    offset += 4;
+    read_and_check_value(TEST_ADDR_EL2 + offset, ((const uint8_t*)&el2_ns_blocks[0]) + offset, OCSD_MEM_SPACE_EL3) ? passed++ : failed++;
+    offset += 4;
+    read_and_check_value(TEST_ADDR_EL2 + offset, ((const uint8_t*)&el2_ns_blocks[0]) + offset, OCSD_MEM_SPACE_S) ? passed++ : failed++;
+
+    oss.str("Test Any R registered block\n");
+    logger.LogMsg(oss.str());
+    offset = 0;
+    read_and_check_value(TEST_ADDR_EL3 + offset, ((const uint8_t*)&el2_ns_blocks[1]) + offset, OCSD_MEM_SPACE_EL1R) ? passed++ : failed++;
+    offset += 4;
+    read_and_check_value(TEST_ADDR_EL3 + offset, ((const uint8_t*)&el2_ns_blocks[1]) + offset, OCSD_MEM_SPACE_EL2R) ? passed++ : failed++;
+    offset += 4;
+    read_and_check_value(TEST_ADDR_EL3 + offset, ((const uint8_t*)&el2_ns_blocks[1]) + offset, OCSD_MEM_SPACE_R) ? passed++ : failed++;
+    offset += 4;
+
+    // clean up
+    mapper.RemoveAllAccessors();
+    tests_passed += passed;
+    tests_failed += failed;
+    log_test_end(__FUNCTION__, passed, failed);
+ }
+
+/************************************************************************
+ * main program 
+ */
+int main(int argc, char* argv[])
+{
+	std::ostringstream oss;
+
+    if (!process_cmd_line_logger_opts(argc, argv))
+    {
+        std::cout << "Bad logger command line options\nProgram Exiting\n";
+        return -1;
+    }
+
+    // init the loggers.
+    logger.setLogOpts(logOpts);
+    logger.setLogFileName(logfileName.c_str());
+    err_log.initErrorLogger(OCSD_ERR_SEV_INFO);
+    err_log_handle = err_log.RegisterErrorSource("MEMACCTEST");
+    err_log.setOutputLogger(&logger);
+
+    oss << "OpenCSD memory access tests.\n";
+    oss << "----------------------------\n\n";
+    oss << "Library Version : " << ocsdVersion::vers_str() << "\n\n";
+    logger.LogMsg(oss.str());
+
+    // set up test data
+    populate_all_blocks();
+
+    // init the mapper
+    mapper.setErrorLog(&err_log);
+    mapper.enableCaching(true);
+
+    // call the test routines
+    test_overlap_regions();
+
+    test_trcid_cache_mem_cb();
+
+    test_mem_spaces();
+
+       
+    oss.str("");
+    oss << "\n*** Memory access tests complete.***\nPassed: " << tests_passed << "; Failed: " << tests_failed << "\n";
+    logger.LogMsg(oss.str());
+  	return (tests_failed == 0) ? 0 : -2;
+}