all commits for a clean git history

pyplot/Histogram/Large/LL_CACHE_MISS.py

@@ -0,0 +1,51 @@
+import matplotlib.pyplot as plt
+import numpy as np
+
+# ypoints = np.array([19636392729, 9856229208,9445728437,5148906386])
+# xpoints = np.array([5,10,15,20])
+
+# ypoints1 = np.array([10062197042, 9873241615,12034929886,5118684853])
+# xpoints1 = np.array([5,10,15,20])
+
+ypoints = np.array(np.array([int(x) for x in """5527931
+             8487180
+             8358903
+             8502471
+             9044249
+             4808340""".replace('             ',',').replace('\n','').split(",")]))
+
+xpoints = np.array([(i) for i, x in enumerate(ypoints, 1)])
+
+ypoints1 = np.array(np.array([int(x) for x in """4215408
+             4561976
+             4696311
+             4662084
+             4618990
+             2799270""".replace('             ',',').replace('\n','').split(",")]))
+
+xpoints1 = np.array([(i) for i, x in enumerate(ypoints1, 1)])
+
+plt.plot(xpoints, ypoints,label='Malloc Physically contigous with bounds')
+plt.plot(xpoints1, ypoints1,label='System memory allocator')
+
+'''
+L1D_CACHE_LMISS_RD
+The counter counts each Memory-read operation to the Level 1 data or unified cache counted by L1D_CACHE that incurs additional latency because it returns data from outside of the Level 1 data or unified cache of this PE.
+The event indicates to software that the access missed in the Level 1 data or unified cache and might have a significant performance impact due to the additional latency compared to the latency of an access that hits in the Level 1 data or unified cache.
+The counter does not count:
+• Accesses where the additional latency is unlikely to be significantly performance-impacting. For example, if the access hits in another cache in the same local cluster, and the additional latency is small when compared to a miss in all Level 1 caches that the access looks up in and results in an access being made to a Level 2 cache or elsewhere beyond the Level 1 data or unified cache.
+• A miss that does not cause a new cache refill but is satisfied from a previous miss.
+An implementation is not required to measure the latency, nor to track the access to determine whether the additional latency caused a performance impact. An implementation can extend the definition of this event with additional scenarios where an access might have a significant performance impact due to additional latency for the access.
+It is IMPLEMENTATION DEFINED whether accesses that result from cache maintenance operations are counted.
+If the cache is shared and the Effective value of PMEVTYPER<n>_EL0.MT for the counter is 0, then the counter counts only events Attributable to the PE counting the event. For a multithreaded processor implementation, if the cache is shared by PEs other than the PEs in the multithreaded processor and the Effective value of PMEVTYPER<n>_EL0.MT for the counter is 1, then the counter counts only events Attributable to PEs in the multithreaded processor. In all other cases, it is IMPLEMENTATION DEFINED whether only events Attributable to the PE counting the event or all events are counted, and might depend on the Effective value of PMEVTYPER<n>_EL1.MT.
+PMCEID1_EL0[25] reads as 1 if this event is implemented and 0 otherwise. This event must be implemented if FEAT_PMUv3p4 is implemented.
+'''
+# plt.title("L1D cache miss read \n ARM Performance counter: L1D_CACHE_LMISS_RD \n each Memory-read operation or Memory-write operation that causes a cache \n access to at least the Level 1 data or unified cache. This includes each complete or partial translation table walk that causes an access to memory, including to data or translation table walk caches. \n Histogram large")
+
+plt.xlabel("time in seconds")
+plt.ylabel("LL cache miss")
+# plt.plot(xpoints1, ypoints1)
+plt.legend()
+# plt.show()
+
+plt.savefig('ll_cache_histogram_large.png')

pyplot/Histogram/Large/TLB-DTLB-walk.py

@@ -0,0 +1,51 @@
+import matplotlib.pyplot as plt
+import numpy as np
+
+# ypoints = np.array([19636392729, 9856229208,9445728437,5148906386])
+# xpoints = np.array([5,10,15,20])
+
+# ypoints1 = np.array([10062197042, 9873241615,12034929886,5118684853])
+# xpoints1 = np.array([5,10,15,20])
+
+ypoints = np.array([int(x) for x in """61346
+        61955
+        64896
+        64751
+        64359
+        24896""".replace('       ',',').replace('\n','').split(",")])
+
+xpoints = np.array([(i) for i, x in enumerate(ypoints, 1)])
+
+ypoints1 = np.array([int(x) for x in """48953
+        74277
+        52782
+        64321
+        64184
+        36170""".replace('        ',',').replace('\n','').split(",")])
+
+xpoints1 = np.array([(i) for i, x in enumerate(ypoints1, 1)])
+
+plt.plot(xpoints, ypoints,label='Malloc Physically contigous with bounds')
+plt.plot(xpoints1, ypoints1,label='System memory allocator')
+
+'''
+DTLB_WALK
+The counter counts each access counted by L1D_TLB that causes a 
+refill of a data or unified 
+TLB involving at least one translation table walk access.
+This includes each complete or partial translation table walk that causes an 
+access to memory, including to data or translation table walk caches.
+If Armv8.7 is not implemented, it is IMPLEMENTATION DEFINED whether accesses 
+that cause an update of an existing TLB entry involving at least one translation 
+table walk access are counted. If Armv8.7 is implemented, these accesses 
+are counted.
+'''
+# plt.title("Data TLB access, read \n ARM Performance counter: DTLB_WALK \n Data TLB access with at least one translation table walk \n This includes each complete or partial translation table walk that causes an access to memory, including to data or translation table walk caches. \n Histogram large")
+
+plt.xlabel("time in seconds")
+plt.ylabel("DTLB walks")
+# plt.plot(xpoints1, ypoints1)
+plt.legend()
+# plt.show()
+
+plt.savefig('dtlb_walk_histogram_large.png')

pyplot/Histogram/Large/TLB-L1-DATA-ACCESS.py

@@ -0,0 +1,46 @@
+import matplotlib.pyplot as plt
+import numpy as np
+
+# ypoints = np.array([19636392729, 9856229208,9445728437,5148906386])
+# xpoints = np.array([5,10,15,20])
+
+# ypoints1 = np.array([10062197042, 9873241615,12034929886,5118684853])
+# xpoints1 = np.array([5,10,15,20])
+
+ypoints = np.array([int(x) for x in """2470621494
+    2375100932
+    2670296613
+    2645401007
+    2876843895
+    1166193957""".replace('    ',',').replace('\n','').split(",")])
+
+xpoints = np.array([(i) for i, x in enumerate(ypoints, 1)])
+
+ypoints1 = np.array([int(x) for x in """2273131353
+    2561823604
+    2693697356
+    2606093836
+    2631231896
+    1161666024""".replace('    ',',').replace('\n','').split(",")])
+
+xpoints1 = np.array([(i) for i, x in enumerate(ypoints1, 1)])
+
+plt.plot(xpoints, ypoints,label='Malloc Physically contigous with bounds')
+plt.plot(xpoints1, ypoints1,label='System memory allocator')
+
+'''
+L1D_TLB
+The counter counts each Memory-read operation or Memory-write operation that causes a TLB
+access to at least the Level 1 data or unified TLB.
+Each access to a TLB entry is counted including multiple accesses caused by single instructions
+such as LDM or STM.
+'''
+# plt.title("Level 1 data TLB access, read \n ARM Performance counter: L1D_TLB_RD \n This counter counts each access counted by \n L1D_TLB that is a Memory-read operation. \n Histogram large")
+
+plt.xlabel("time in seconds")
+plt.ylabel("L1 DTLB reads")
+# plt.plot(xpoints1, ypoints1)
+plt.legend()
+# plt.show()
+
+plt.savefig('tlb_l1_data.png')

pyplot/Histogram/Large/TLB-L2D_TLB.py

@@ -0,0 +1,50 @@
+import matplotlib.pyplot as plt
+import numpy as np
+
+# ypoints = np.array([19636392729, 9856229208,9445728437,5148906386])
+# xpoints = np.array([5,10,15,20])
+
+# ypoints1 = np.array([10062197042, 9873241615,12034929886,5118684853])
+# xpoints1 = np.array([5,10,15,20])
+
+
+ypoints = np.array([int(x) for x in """140262
+      156781
+      156217
+      155686
+      139859
+      80438""".replace('      ',',').replace('\n','').split(",")])
+
+xpoints = np.array([(i) for i, x in enumerate(ypoints, 1)])
+
+ypoints1 = np.array([int(x) for x in """121530
+      144628
+      154478
+      143992
+      148316
+      86682""".replace('      ',',').replace('\n','').split(",")])
+
+xpoints1 = np.array([(i) for i, x in enumerate(ypoints1, 1)])
+
+xpoints1 = np.array([(i) for i, x in enumerate(ypoints1, 1)])
+
+plt.plot(xpoints, ypoints,label='Malloc Physically contigous with bounds')
+plt.plot(xpoints1, ypoints1,label='System memory allocator')
+
+'''
+DTLB_WALK
+The counter counts each Memory-read operation or Memory-write operation that causes a 
+TLB access to at least the Level 2 data or unified TLB.
+Each access to a TLB entry is counted including refills 
+of Level 1 TLBs.
+The counter does not count the access if the access i
+s due to a TLB maintenance instruction.
+'''
+# plt.title("Level 2 data TLB acces, read \n ARM Performance counter: L2D_TLB \n The counter counts each Memory-read operation or Memory-write operation that causes a TLB access to at least the Level 2 data or unified TLB. \n Histogram large")
+
+plt.xlabel("time in seconds")
+plt.ylabel("L2 DTLB reads")
+# plt.plot(xpoints1, ypoints1)
+plt.legend()
+# plt.show()
+plt.savefig('tlb_l2_data.png')

pyplot/Histogram/Medium/LL_CACHE_MISS.py

@@ -0,0 +1,43 @@
+import matplotlib.pyplot as plt
+import numpy as np
+
+# ypoints = np.array([19636392729, 9856229208,9445728437,5148906386])
+# xpoints = np.array([5,10,15,20])
+
+# ypoints1 = np.array([10062197042, 9873241615,12034929886,5118684853])
+# xpoints1 = np.array([5,10,15,20])
+
+ypoints = np.array(np.array([int(x) for x in """7409968
+             5549675""".replace('             ',',').replace('\n','').split(",")]))
+
+xpoints = np.array([(i) for i, x in enumerate(ypoints, 1)])
+
+ypoints1 = np.array(np.array([int(x) for x in """3946380
+             3530306""".replace('             ',',').replace('\n','').split(",")]))
+
+xpoints1 = np.array([(i) for i, x in enumerate(ypoints1, 1)])
+
+plt.plot(xpoints, ypoints,label='Malloc Physically contigous with bounds')
+plt.plot(xpoints1, ypoints1,label='System memory allocator')
+
+'''
+L1D_CACHE_LMISS_RD
+The counter counts each Memory-read operation to the Level 1 data or unified cache counted by L1D_CACHE that incurs additional latency because it returns data from outside of the Level 1 data or unified cache of this PE.
+The event indicates to software that the access missed in the Level 1 data or unified cache and might have a significant performance impact due to the additional latency compared to the latency of an access that hits in the Level 1 data or unified cache.
+The counter does not count:
+• Accesses where the additional latency is unlikely to be significantly performance-impacting. For example, if the access hits in another cache in the same local cluster, and the additional latency is small when compared to a miss in all Level 1 caches that the access looks up in and results in an access being made to a Level 2 cache or elsewhere beyond the Level 1 data or unified cache.
+• A miss that does not cause a new cache refill but is satisfied from a previous miss.
+An implementation is not required to measure the latency, nor to track the access to determine whether the additional latency caused a performance impact. An implementation can extend the definition of this event with additional scenarios where an access might have a significant performance impact due to additional latency for the access.
+It is IMPLEMENTATION DEFINED whether accesses that result from cache maintenance operations are counted.
+If the cache is shared and the Effective value of PMEVTYPER<n>_EL0.MT for the counter is 0, then the counter counts only events Attributable to the PE counting the event. For a multithreaded processor implementation, if the cache is shared by PEs other than the PEs in the multithreaded processor and the Effective value of PMEVTYPER<n>_EL0.MT for the counter is 1, then the counter counts only events Attributable to PEs in the multithreaded processor. In all other cases, it is IMPLEMENTATION DEFINED whether only events Attributable to the PE counting the event or all events are counted, and might depend on the Effective value of PMEVTYPER<n>_EL1.MT.
+PMCEID1_EL0[25] reads as 1 if this event is implemented and 0 otherwise. This event must be implemented if FEAT_PMUv3p4 is implemented.
+'''
+# plt.title("L1D cache miss read \n ARM Performance counter: L1D_CACHE_LMISS_RD \n each Memory-read operation or Memory-write operation that causes a cache \n access to at least the Level 1 data or unified cache. This includes each complete or partial translation table walk that causes an access to memory, including to data or translation table walk caches. \n Histogram medium")
+
+plt.xlabel("time in seconds")
+plt.ylabel("cache miss")
+# plt.plot(xpoints1, ypoints1)
+plt.legend()
+# plt.show()
+
+plt.savefig('ll_data_histogram_medium.png')

pyplot/Histogram/Medium/TLB-DTLB-walk.py

@@ -0,0 +1,43 @@
+import matplotlib.pyplot as plt
+import numpy as np
+
+# ypoints = np.array([19636392729, 9856229208,9445728437,5148906386])
+# xpoints = np.array([5,10,15,20])
+
+# ypoints1 = np.array([10062197042, 9873241615,12034929886,5118684853])
+# xpoints1 = np.array([5,10,15,20])
+
+ypoints = np.array([int(x) for x in """60650
+        38635""".replace('       ',',').replace('\n','').split(",")])
+
+xpoints = np.array([(i) for i, x in enumerate(ypoints, 1)])
+
+ypoints1 = np.array([int(x) for x in """41348
+        39676""".replace('        ',',').replace('\n','').split(",")])
+
+xpoints1 = np.array([(i) for i, x in enumerate(ypoints1, 1)])
+
+plt.plot(xpoints, ypoints,label='Malloc Physically contigous with bounds')
+plt.plot(xpoints1, ypoints1,label='System memory allocator')
+
+'''
+DTLB_WALK
+The counter counts each access counted by L1D_TLB that causes a 
+refill of a data or unified 
+TLB involving at least one translation table walk access.
+This includes each complete or partial translation table walk that causes an 
+access to memory, including to data or translation table walk caches.
+If Armv8.7 is not implemented, it is IMPLEMENTATION DEFINED whether accesses 
+that cause an update of an existing TLB entry involving at least one translation 
+table walk access are counted. If Armv8.7 is implemented, these accesses 
+are counted.
+'''
+# plt.title("Data TLB access, read \n ARM Performance counter: DTLB_WALK \n Data TLB access with at least one translation table walk \n This includes each complete or partial translation table walk that causes an access to memory, including to data or translation table walk caches. \n Histogram medium")
+
+plt.xlabel("time in seconds")
+plt.ylabel("DTLB walks")
+# plt.plot(xpoints1, ypoints1)
+plt.legend()
+# plt.show()
+
+plt.savefig('dtlb_walk_histogram_medium.png')

pyplot/Histogram/Medium/TLB-L1-DATA-ACCESS.py

@@ -0,0 +1,38 @@
+import matplotlib.pyplot as plt
+import numpy as np
+
+# ypoints = np.array([19636392729, 9856229208,9445728437,5148906386])
+# xpoints = np.array([5,10,15,20])
+
+# ypoints1 = np.array([10062197042, 9873241615,12034929886,5118684853])
+# xpoints1 = np.array([5,10,15,20])
+
+ypoints = np.array([int(x) for x in """2031641198
+    1792581571""".replace('    ',',').replace('\n','').split(",")])
+
+xpoints = np.array([(i) for i, x in enumerate(ypoints, 1)])
+
+ypoints1 = np.array([int(x) for x in """2041386981
+    2064066636""".replace('    ',',').replace('\n','').split(",")])
+
+xpoints1 = np.array([(i) for i, x in enumerate(ypoints1, 1)])
+
+plt.plot(xpoints, ypoints,label='Malloc Physically contigous with bounds')
+plt.plot(xpoints1, ypoints1,label='System memory allocator')
+
+'''
+L1D_TLB
+The counter counts each Memory-read operation or Memory-write operation that causes a TLB
+access to at least the Level 1 data or unified TLB.
+Each access to a TLB entry is counted including multiple accesses caused by single instructions
+such as LDM or STM.
+'''
+# plt.title("Level 1 data TLB access, read \n ARM Performance counter: L1D_TLB_RD \n This counter counts each access counted by \n L1D_TLB that is a Memory-read operation. \n Histogram medium")
+
+plt.xlabel("time in seconds")
+plt.ylabel("L1 DTLB reads")
+# plt.plot(xpoints1, ypoints1)
+plt.legend()
+# plt.show()
+
+plt.savefig('l1_data_histogram_medium.png')

pyplot/Histogram/Medium/TLB-L2D_TLB.py

@@ -0,0 +1,43 @@
+import matplotlib.pyplot as plt
+import numpy as np
+
+# ypoints = np.array([19636392729, 9856229208,9445728437,5148906386])
+# xpoints = np.array([5,10,15,20])
+
+# ypoints1 = np.array([10062197042, 9873241615,12034929886,5118684853])
+# xpoints1 = np.array([5,10,15,20])
+
+
+ypoints = np.array([int(x) for x in """159185
+       95485""".replace('       ',',').replace('\n','').split(",")])
+
+xpoints = np.array([(i) for i, x in enumerate(ypoints, 1)])
+
+ypoints1 = np.array([int(x) for x in """137015
+       89117""".replace('       ',',').replace('\n','').split(",")])
+
+xpoints1 = np.array([(i) for i, x in enumerate(ypoints1, 1)])
+
+xpoints1 = np.array([(i) for i, x in enumerate(ypoints1, 1)])
+
+plt.plot(xpoints, ypoints,label='Malloc Physically contigous with bounds')
+plt.plot(xpoints1, ypoints1,label='System memory allocator')
+
+'''
+DTLB_WALK
+The counter counts each Memory-read operation or Memory-write operation that causes a 
+TLB access to at least the Level 2 data or unified TLB.
+Each access to a TLB entry is counted including refills 
+of Level 1 TLBs.
+The counter does not count the access if the access i
+s due to a TLB maintenance instruction.
+'''
+# plt.title("Level 2 data TLB acces, read \n ARM Performance counter: L2D_TLB \n The counter counts each Memory-read operation or Memory-write operation that causes a TLB access to at least the Level 2 data or unified TLB. \n Histogram medium")
+
+plt.xlabel("time in seconds")
+plt.ylabel("L2 DTLB reads")
+# plt.plot(xpoints1, ypoints1)
+plt.legend()
+# plt.show()
+
+plt.savefig('tlb_l2_histogram_medium.png')

pyplot/Histogram/Physically-contigous.txt

@@ -0,0 +1,60 @@
+# p/ll_cache_miss_rd
+             2100870
+#  p/L2D_TLB
+       70087
+# p/DTLB_WALK
+        18523
+# p/L1D_TLB_RD
+     947507000
+#  p/L2D_TLB
+       64140
+# p/ll_cache_miss_rd
+             7409968
+             5549675
+#  p/L2D_TLB
+      155420
+       91895
+# p/DTLB_WALK
+        60650
+        38635
+# p/L1D_TLB_RD
+    2031641198
+    1792581571
+#  p/L2D_TLB
+      159185
+       95485
+# p/ll_cache_miss_rd
+             5527931
+             8487180
+             8358903
+             8502471
+             9044249
+             4808340
+#  p/L2D_TLB
+      123036
+      155010
+      180732
+      155543
+      154428
+       64508
+# p/DTLB_WALK
+        61346
+        61955
+        64896
+        64751
+        64359
+        24896
+# p/L1D_TLB_RD
+    2470621494
+    2375100932
+    2670296613
+    2645401007
+    2876843895
+    1166193957
+#  p/L2D_TLB
+      140262
+      156781
+      156217
+      155686
+      139859
+       80438

pyplot/Histogram/Small/LL_CACHE_MISS.py

@@ -0,0 +1,41 @@
+import matplotlib.pyplot as plt
+import numpy as np
+
+# ypoints = np.array([19636392729, 9856229208,9445728437,5148906386])
+# xpoints = np.array([5,10,15,20])
+
+# ypoints1 = np.array([10062197042, 9873241615,12034929886,5118684853])
+# xpoints1 = np.array([5,10,15,20])
+
+ypoints = np.array([2100870,19384360])
+
+xpoints = ["Malloc Physically contigous with bounds","System memory allocator"]
+
+# ypoints1 = np.array([19384360])
+
+# xpoints1 = np.array([(i) for i, x in enumerate(ypoints1, 1)])
+
+plt.bar(xpoints, ypoints)
+# plt.bar(xpoints1, ypoints1,label='System memory allocator')
+
+'''
+L1D_CACHE_LMISS_RD
+The counter counts each Memory-read operation to the Level 1 data or unified cache counted by L1D_CACHE that incurs additional latency because it returns data from outside of the Level 1 data or unified cache of this PE.
+The event indicates to software that the access missed in the Level 1 data or unified cache and might have a significant performance impact due to the additional latency compared to the latency of an access that hits in the Level 1 data or unified cache.
+The counter does not count:
+• Accesses where the additional latency is unlikely to be significantly performance-impacting. For example, if the access hits in another cache in the same local cluster, and the additional latency is small when compared to a miss in all Level 1 caches that the access looks up in and results in an access being made to a Level 2 cache or elsewhere beyond the Level 1 data or unified cache.
+• A miss that does not cause a new cache refill but is satisfied from a previous miss.
+An implementation is not required to measure the latency, nor to track the access to determine whether the additional latency caused a performance impact. An implementation can extend the definition of this event with additional scenarios where an access might have a significant performance impact due to additional latency for the access.
+It is IMPLEMENTATION DEFINED whether accesses that result from cache maintenance operations are counted.
+If the cache is shared and the Effective value of PMEVTYPER<n>_EL0.MT for the counter is 0, then the counter counts only events Attributable to the PE counting the event. For a multithreaded processor implementation, if the cache is shared by PEs other than the PEs in the multithreaded processor and the Effective value of PMEVTYPER<n>_EL0.MT for the counter is 1, then the counter counts only events Attributable to PEs in the multithreaded processor. In all other cases, it is IMPLEMENTATION DEFINED whether only events Attributable to the PE counting the event or all events are counted, and might depend on the Effective value of PMEVTYPER<n>_EL1.MT.
+PMCEID1_EL0[25] reads as 1 if this event is implemented and 0 otherwise. This event must be implemented if FEAT_PMUv3p4 is implemented.
+'''
+# plt.title("L1D cache miss read \n ARM Performance counter: L1D_CACHE_LMISS_RD \n each Memory-read operation or Memory-write operation that causes a cache \n access to at least the Level 1 data or unified cache. This includes each complete or partial translation table walk that causes an access to memory, including to data or translation table walk caches. \n Histogram medium")
+
+plt.xlabel("time in seconds")
+plt.ylabel("L1D cache misses")
+# plt.plot(xpoints1, ypoints1)
+plt.legend()
+# plt.show()
+
+plt.savefig('ll_histogram_small.png')

pyplot/Histogram/Small/TLB-DTLB-walk.py

@@ -0,0 +1,37 @@
+import matplotlib.pyplot as plt
+import numpy as np
+
+# ypoints = np.array([19636392729, 9856229208,9445728437,5148906386])
+# xpoints = np.array([5,10,15,20])
+
+# ypoints1 = np.array([10062197042, 9873241615,12034929886,5118684853])
+# xpoints1 = np.array([5,10,15,20])
+
+ypoints = np.array([18523,16667])
+
+xpoints = ["Malloc Physically contigous with bounds","System memory allocator"]
+
+
+plt.bar(xpoints, ypoints)
+
+'''
+DTLB_WALK
+The counter counts each access counted by L1D_TLB that causes a 
+refill of a data or unified 
+TLB involving at least one translation table walk access.
+This includes each complete or partial translation table walk that causes an 
+access to memory, including to data or translation table walk caches.
+If Armv8.7 is not implemented, it is IMPLEMENTATION DEFINED whether accesses 
+that cause an update of an existing TLB entry involving at least one translation 
+table walk access are counted. If Armv8.7 is implemented, these accesses 
+are counted.
+'''
+# plt.title("Data TLB access, read \n ARM Performance counter: DTLB_WALK \n Data TLB access with at least one translation table walk \n This includes each complete or partial translation table walk that causes an access to memory, including to data or translation table walk caches. \n Histogram medium")
+
+plt.xlabel("time in seconds")
+plt.ylabel("DTLB walks")
+# plt.plot(xpoints1, ypoints1)
+plt.legend()
+# plt.show()
+
+plt.savefig('dtlb_walk_histogram_small.png')

pyplot/Histogram/Small/TLB-L1-DATA-ACCESS.py

@@ -0,0 +1,31 @@
+import matplotlib.pyplot as plt
+import numpy as np
+
+# ypoints = np.array([19636392729, 9856229208,9445728437,5148906386])
+# xpoints = np.array([5,10,15,20])
+
+# ypoints1 = np.array([10062197042, 9873241615,12034929886,5118684853])
+# xpoints1 = np.array([5,10,15,20])
+
+ypoints = np.array([947507000,771906538])
+
+xpoints = ["Malloc Physically contigous with bounds","System memory allocator"]
+
+plt.bar(xpoints, ypoints,label='Malloc Physically contigous with bounds')
+
+'''
+L1D_TLB
+The counter counts each Memory-read operation or Memory-write operation that causes a TLB
+access to at least the Level 1 data or unified TLB.
+Each access to a TLB entry is counted including multiple accesses caused by single instructions
+such as LDM or STM.
+'''
+# plt.title("Level 1 data TLB access, read \n ARM Performance counter: L1D_TLB_RD \n This counter counts each access counted by \n L1D_TLB that is a Memory-read operation. \n Histogram medium")
+
+plt.xlabel("time in seconds")
+plt.ylabel("L1 DTLB reads")
+# plt.plot(xpoints1, ypoints1)
+# plt.legend()
+# plt.show()
+
+plt.savefig('l1d_tlb_walk_histogram_small.png')

pyplot/Histogram/Small/TLB-L2D_TLB.py

@@ -0,0 +1,33 @@
+import matplotlib.pyplot as plt
+import numpy as np
+
+# ypoints = np.array([19636392729, 9856229208,9445728437,5148906386])
+# xpoints = np.array([5,10,15,20])
+
+# ypoints1 = np.array([10062197042, 9873241615,12034929886,5118684853])
+# xpoints1 = np.array([5,10,15,20])
+
+
+ypoints = np.array([64140,46518])
+
+xpoints = ["Malloc Physically contigous with bounds","System memory allocator"]
+
+plt.bar(xpoints, ypoints)
+
+'''
+The counter counts each Memory-read operation or Memory-write operation that causes a 
+TLB access to at least the Level 2 data or unified TLB.
+Each access to a TLB entry is counted including refills 
+of Level 1 TLBs.
+The counter does not count the access if the access i
+s due to a TLB maintenance instruction.
+'''
+# plt.title("Level 2 data TLB acces, read \n ARM Performance counter: L2D_TLB \n The counter counts each Memory-read operation or Memory-write operation that causes a TLB access to at least the Level 2 data or unified TLB. \n Histogram medium")
+
+plt.xlabel("time in seconds")
+plt.ylabel("L2 DTLB reads")
+# plt.plot(xpoints1, ypoints1)
+plt.legend()
+# plt.show()
+
+plt.savefig('l2d_tlb_walk_histogram_small.png')

pyplot/Histogram/System-Allocator.txt

@@ -0,0 +1,60 @@
+# p/ll_cache_miss_rd
+             1938436
+#  p/L2D_TLB
+       66692
+# p/DTLB_WALK
+        16667
+# p/L1D_TLB_RD
+     771906538
+#  p/L2D_TLB
+       46518
+# p/ll_cache_miss_rd
+             3946380
+             3530306
+#  p/L2D_TLB
+      141073
+      105804
+# p/DTLB_WALK
+        41348
+        39676
+# p/L1D_TLB_RD
+    2041386981
+    2064066636
+#  p/L2D_TLB
+      137015
+       89117
+# p/ll_cache_miss_rd
+             4215408
+             4561976
+             4696311
+             4662084
+             4618990
+             2799270
+#  p/L2D_TLB
+      115992
+      154771
+      151387
+      148955
+      148124
+       57792
+# p/DTLB_WALK
+        48953
+        74277
+        52782
+        64321
+        64184
+        36170
+# p/L1D_TLB_RD
+    2273131353
+    2561823604
+    2693697356
+    2606093836
+    2631231896
+    1161666024
+#  p/L2D_TLB
+      121530
+      144628
+      154478
+      143992
+      148316
+       86682