Applied some optimizations for performance. Python is very easily overwhelmed with plenty of calls, causing too much overhead

Author: Byron

smmap/mman.py

@@ -99,18 +99,30 @@ def use_region(self, offset, size, _is_recursive=False):
 		# END check existing region
 
 		if need_region:
+			window_size = man._window_size
+			
 			# abort on offsets beyond our mapped file's size - currently we are invalid
 			if offset >= self.file_size():
 				return self
 			# END handle offset too large
 
 			existing_region = None
-			for region in self._rlist:
-				if region.includes_ofs(offset):
-					existing_region = region
-					break
-				#END handle existing region
-			#END for each existing region
+			a = self._rlist
+			lo = 0
+			hi = len(a)
+			while lo < hi:
+				mid = (lo+hi)//2
+				ofs = a[mid]._b
+				if ofs <= offset:
+					if a[mid].includes_ofs(offset):
+						existing_region = a[mid]
+						break
+					#END have region
+					lo = mid+1
+				else:
+					hi = mid
+				#END handle position
+			#END while bisecting
 
 			if existing_region is None:
 				left = MemoryWindow(0, 0)
@@ -119,20 +131,23 @@ def use_region(self, offset, size, _is_recursive=False):
 
 				# we want to honor the max memory size, and assure we have anough
 				# memory available
-				man._collect_lru_region(man.window_size())
+				# Save calls !
+				if self._manager._memory_size + window_size > self._manager._max_memory_size:
+					man._collect_lru_region(window_size)
+				#END handle collection
 
 				# we assume the list remains sorted by offset
 				insert_pos = 0
-				len_regions = len(self._rlist)
+				len_regions = len(a)
 				if len_regions == 1:
-					if self._rlist[0].ofs_begin() <= offset:
+					if a[0]._b <= offset:
 						insert_pos = 1
 					#END maintain sort
 				else:
 					# find insert position
 					insert_pos = len_regions
-					for i, region in enumerate(self._rlist):
-						if region.ofs_begin() > offset:
+					for i, region in enumerate(a):
+						if region._b > offset:
 							insert_pos = i
 							break
 						#END if insert position is correct
@@ -143,17 +158,17 @@ def use_region(self, offset, size, _is_recursive=False):
 				# possible mapping
 				if insert_pos == 0:
 					if len_regions:
-						right = MemoryWindow.from_region(self._rlist[insert_pos])
+						right = MemoryWindow.from_region(a[insert_pos])
 					#END adjust right side 
 				else:
 					if insert_pos != len_regions:
-						right = MemoryWindow.from_region(self._rlist[insert_pos])
+						right = MemoryWindow.from_region(a[insert_pos])
 					# END adjust right window
-					left = MemoryWindow.from_region(self._rlist[insert_pos - 1])
+					left = MemoryWindow.from_region(a[insert_pos - 1])
 				#END adjust surrounding windows
 
-				mid.extend_left_to(left, man._window_size)
-				mid.extend_right_to(right, man._window_size)
+				mid.extend_left_to(left, window_size)
+				mid.extend_right_to(right, window_size)
 				mid.align()
 
 				# it can happen that we align beyond the end of the file
@@ -166,7 +181,7 @@ def use_region(self, offset, size, _is_recursive=False):
 					if man._handle_count >= man._max_handle_count:
 						raise Exception
 					#END assert own imposed max file handles
-					self._region = MappedRegion(self._rlist.path(), mid.ofs, mid.size)
+					self._region = MappedRegion(a.path(), mid.ofs, mid.size)
 				except Exception:
 					# apparently we are out of system resources or hit a limit
 					# As many more operations are likely to fail in that condition (
@@ -185,14 +200,14 @@ def use_region(self, offset, size, _is_recursive=False):
 
 				man._handle_count += 1
 				man._memory_size += self._region.size()
-				self._rlist.insert(insert_pos, self._region)
+				a.insert(insert_pos, self._region)
 			else:
 				self._region = existing_region
 			#END need region handling
 		#END handle acquire region
 
 		self._region.increment_usage_count()
-		self._ofs = offset - self._region.ofs_begin()
+		self._ofs = offset - self._region._b
 		self._size = min(size, self._region.ofs_end() - offset)
 
 		return self
@@ -220,12 +235,12 @@ def is_associated(self):
 
 	def ofs_begin(self):
 		""":return: offset to the first byte pointed to by our cursor"""
-		return self._region.ofs_begin() + self._ofs
+		return self._region._b + self._ofs
 
 	def ofs_end(self):
 		""":return: offset to one past the last available byte"""
 		# unroll method calls for performance !
-		return self._region.ofs_begin() + self._ofs + self._size
+		return self._region._b + self._ofs + self._size
 
 	def size(self):
 		""":return: amount of bytes we point to"""
@@ -241,10 +256,9 @@ def region_ref(self):
 	def includes_ofs(self, ofs):
 		""":return: True if the given absolute offset is contained in the cursors 
 			current region
-		:note: always False if the cursor does not point to a valid region"""
-		if self._region is None:
-			return False
-		return self.ofs_begin() <= ofs < self.ofs_end()
+		:note: cursor must be valid for this to work"""
+		# unroll methods
+		return (self._region._b + self._ofs) <= ofs < (self._region._b + self._ofs + self._size)
 
 	def file_size(self):
 		""":return: size of the underlying file"""
@@ -327,7 +341,7 @@ def _collect_lru_region(self, size):
 				for region in regions:
 					# check client count - consider that we keep one reference ourselves !
 					if (region.client_count()-2 == 0 and 
-						(lru_region is None or region.usage_count() < lru_region.usage_count())):
+						(lru_region is None or region._uc < lru_region._uc)):
 						lru_region = region
 						lru_list = regions
 					# END update lru_region

smmap/test/test_mman.py

@@ -127,33 +127,39 @@ def test_memman_operation(self):
 		# remove mapped regions if we have to
 		assert man.num_file_handles() == 2
 
-		# an offset as large as the size doesn't work !
-		assert not c.use_region(fc.size, size).is_valid() 
-
 		# iterate through the windows, verify data contents
 		# this will trigger map collection after a while
 		max_random_accesses = 15000
 		num_random_accesses = max_random_accesses
 		memory_read = 0
 		st = time()
 
+		# cache everything to get some more performance
+		includes_ofs = c.includes_ofs
+		max_mapped_memory_size = man.max_mapped_memory_size()
+		max_file_handles = man.max_file_handles()
+		mapped_memory_size = man.mapped_memory_size
+		num_file_handles = man.num_file_handles
 		while num_random_accesses:
 			num_random_accesses -= 1
 			base_offset = randint(0, fc.size - 1)
 
 			# precondition
-			assert man.max_mapped_memory_size() >= man.mapped_memory_size()
-			assert man.max_file_handles() >= man.num_file_handles()
+			assert max_mapped_memory_size >= mapped_memory_size()
+			assert max_file_handles >= num_file_handles()
 			assert c.use_region(base_offset, size).is_valid()
-			assert c.buffer()[:] == data[base_offset:base_offset+c.size()]
-			memory_read += c.size()
+			csize = c.size()
+			assert c.buffer()[:] == data[base_offset:base_offset+csize]
+			memory_read += csize
 
-			assert c.includes_ofs(base_offset)
-			assert c.includes_ofs(base_offset+c.size()-1)
-			assert not c.includes_ofs(base_offset+c.size())
+			assert includes_ofs(base_offset)
+			assert includes_ofs(base_offset+csize-1)
+			assert not includes_ofs(base_offset+csize)
 		# END while we should do an access
 		elapsed = time() - st
 		mb = 1000 * 1000
-		sys.stderr.write("Read %i mb of memory with %i random accesses in %f s(%f mb/s)\n" 
+		sys.stderr.write("Read %i mb of memory with %i random accesses in %fs (%f mb/s)\n" 
 						% (memory_read/mb, max_random_accesses, elapsed, (memory_read/mb)/elapsed))
 
+		# an offset as large as the size doesn't work !
+		assert not c.use_region(fc.size, size).is_valid() 

smmap/util.py

@@ -3,7 +3,7 @@
 import sys
 import mmap
 
-from mmap import PAGESIZE
+from mmap import PAGESIZE, mmap, ACCESS_READ
 from sys import getrefcount
 
 __all__ = [	"align_to_page", "is_64_bit",
@@ -48,7 +48,7 @@ def __repr__(self):
 	@classmethod
 	def from_region(cls, region):
 		""":return: new window from a region"""
-		return cls(region.ofs_begin(), region.size())
+		return cls(region._b, region._size)
 
 	def ofs_end(self):
 		return self.ofs + self.size
@@ -83,6 +83,7 @@ class MappedRegion(object):
 					'_b'	, 	# beginning of mapping
 					'_mf',	# mapped memory chunk (as returned by mmap)
 					'_uc',	# total amount of usages
+					'_size', # cached size of our memory map
 					'__weakref__'
 				]
 	_need_compat_layer = sys.version_info[1] < 6
@@ -100,11 +101,12 @@ def __init__(self, path, ofs, size):
 			allocated the the size automatically adjusted
 		:raise Exception: if no memory can be allocated"""
 		self._b = ofs
+		self._size = 0
 		self._uc = 0
 
 		fd = os.open(path, os.O_RDONLY|getattr(os, 'O_BINARY', 0))
 		try:
-			kwargs = dict(access=mmap.ACCESS_READ, offset=ofs)
+			kwargs = dict(access=ACCESS_READ, offset=ofs)
 			corrected_size = size
 			sizeofs = ofs
 			if self._need_compat_layer:
@@ -116,7 +118,8 @@ def __init__(self, path, ofs, size):
 			# have to correct size, otherwise (instead of the c version) it will 
 			# bark that the size is too large ... many extra file accesses because
 			# if this ... argh !
-			self._mf = mmap.mmap(fd, min(os.fstat(fd).st_size - sizeofs, corrected_size), **kwargs)
+			self._mf = mmap(fd, min(os.fstat(fd).st_size - sizeofs, corrected_size), **kwargs)
+			self._size = len(self._mf)
 
 			if self._need_compat_layer:
 				self._mfb = buffer(self._mf, ofs, size)
@@ -126,7 +129,7 @@ def __init__(self, path, ofs, size):
 		#END close file handle
 
 	def __repr__(self):
-		return "MappedRegion<%i, %i>" % (self._b, self.size())
+		return "MappedRegion<%i, %i>" % (self._b, self._size)
 
 	#{ Interface
 
@@ -140,15 +143,15 @@ def ofs_begin(self):
 
 	def size(self):
 		""":return: total size of the mapped region in bytes"""
-		return len(self._mf)
+		return self._size
 
 	def ofs_end(self):
 		""":return: Absolute offset to one byte beyond the mapping into the file"""
-		return self._b + self.size()
+		return self._b + self._size
 
 	def includes_ofs(self, ofs):
 		""":return: True if the given offset can be read in our mapped region"""
-		return self.ofs_begin() <= ofs < self.ofs_end()
+		return self._b <= ofs < self._b + self._size
 
 	def client_count(self):
 		""":return: number of clients currently using this region"""