Fixed a few little issues, the random access test/perftest now work perfectly. Its not too slow either, 160MB/s compared to the 320MB/s that the c++ implementation gets in release mode. Its odd that for some reason, the Debug version of the c++ implementation is at 940MB/s, which is more like the performance i would have expected

Author: Byron

smmap/mman.py

@@ -244,7 +244,7 @@ def includes_ofs(self, ofs):
 		: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) and (ofs < self.ofs_end())
+		return self.ofs_begin() <= ofs < self.ofs_end()
 
 	def file_size(self):
 		""":return: size of the underlying file"""
@@ -326,7 +326,7 @@ def _collect_lru_region(self, size):
 			for regions in self._fdict.itervalues():
 				for region in regions:
 					# check client count - consider that we keep one reference ourselves !
-					if (region.client_count()-1 == 0 and 
+					if (region.client_count()-2 == 0 and 
 						(lru_region is None or region.usage_count() < lru_region.usage_count())):
 						lru_region = region
 						lru_list = regions

smmap/test/test_mman.py

@@ -138,15 +138,14 @@ def test_memman_operation(self):
 		st = time()
 
 		while num_random_accesses:
-			num_random_accesses += 1
+			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 c.use_region(base_offset, size).is_valid()
-			assert c.buffer()[:] == data[base_offset:base_offset+size]
+			assert c.buffer()[:] == data[base_offset:base_offset+c.size()]
 			memory_read += c.size()
 
 			assert c.includes_ofs(base_offset)

smmap/util.py

@@ -116,7 +116,7 @@ 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 - sizeofs), **kwargs)
+			self._mf = mmap.mmap(fd, min(os.fstat(fd).st_size - sizeofs, corrected_size), **kwargs)
 
 			if self._need_compat_layer:
 				self._mfb = buffer(self._mf, ofs, size)
@@ -125,6 +125,11 @@ def __init__(self, path, ofs, size):
 			os.close(fd)
 		#END close file handle
 
+	def __repr__(self):
+		return "MappedRegion<%i, %i>" % (self._b, self.size())
+		
+	#{ Interface
+		
 	def buffer(self):
 		""":return: a sliceable buffer which can be used to access the mapped memory"""
 		return self._mf
@@ -143,7 +148,7 @@ def ofs_end(self):
 
 	def includes_ofs(self, ofs):
 		""":return: True if the given offset can be read in our mapped region"""
-		return (ofs >= self.ofs_begin()) and (ofs <= self.ofs_end())
+		return self.ofs_begin() <= ofs < self.ofs_end()
 
 	def client_count(self):
 		""":return: number of clients currently using this region"""
@@ -170,6 +175,8 @@ def buffer(self):
 			return self._mfb
 	#END handle compat layer
 
+	#} END interface
+	
 
 class MappedRegionList(list):
 	"""List of MappedRegion instances associating a path with a list of regions."""