Lines Matching refs:self
38 def __init__(self, size):
39 self.size = size
41 name = 'pym-%d-%s' % (os.getpid(), next(self._rand))
49 self.name = name
50 self.buffer = buf
51 self._state = (self.size, self.name)
53 def __getstate__(self):
54 assert_spawning(self)
55 return self._state
57 def __setstate__(self, state):
58 self.size, self.name = self._state = state
60 self.buffer = mmap.mmap(-1, self.size, tagname=self.name)
77 def __init__(self, size, fd=-1):
78 self.size = size
79 self.fd = fd
83 self.fd, name = tempfile.mkstemp(
85 dir=self._choose_dir(size))
87 util.Finalize(self, os.close, (self.fd,))
88 os.ftruncate(self.fd, size)
89 self.buffer = mmap.mmap(self.fd, self.size)
91 def _choose_dir(self, size):
94 for d in self._dir_candidates:
123 def __init__(self, size=mmap.PAGESIZE):
124 self._lastpid = os.getpid()
125 self._lock = threading.Lock()
127 self._size = size
129 self._lengths = []
133 self._len_to_seq = {}
136 self._start_to_block = {}
139 self._stop_to_block = {}
142 self._allocated_blocks = defaultdict(set)
143 self._arenas = []
146 self._pending_free_blocks = []
149 self._n_mallocs = 0
150 self._n_frees = 0
158 def _new_arena(self, size):
160 length = self._roundup(max(self._size, size), mmap.PAGESIZE)
163 if self._size < self._DOUBLE_ARENA_SIZE_UNTIL:
164 self._size *= 2
167 self._arenas.append(arena)
170 def _discard_arena(self, arena):
175 if length < self._DISCARD_FREE_SPACE_LARGER_THAN:
177 blocks = self._allocated_blocks.pop(arena)
179 del self._start_to_block[(arena, 0)]
180 del self._stop_to_block[(arena, length)]
181 self._arenas.remove(arena)
182 seq = self._len_to_seq[length]
185 del self._len_to_seq[length]
186 self._lengths.remove(length)
188 def _malloc(self, size):
190 i = bisect.bisect_left(self._lengths, size)
191 if i == len(self._lengths):
192 return self._new_arena(size)
194 length = self._lengths[i]
195 seq = self._len_to_seq[length]
198 del self._len_to_seq[length], self._lengths[i]
201 del self._start_to_block[(arena, start)]
202 del self._stop_to_block[(arena, stop)]
205 def _add_free_block(self, block):
210 prev_block = self._stop_to_block[(arena, start)]
214 start, _ = self._absorb(prev_block)
217 next_block = self._start_to_block[(arena, stop)]
221 _, stop = self._absorb(next_block)
227 self._len_to_seq[length].append(block)
229 self._len_to_seq[length] = [block]
230 bisect.insort(self._lengths, length)
232 self._start_to_block[(arena, start)] = block
233 self._stop_to_block[(arena, stop)] = block
235 def _absorb(self, block):
238 del self._start_to_block[(arena, start)]
239 del self._stop_to_block[(arena, stop)]
242 seq = self._len_to_seq[length]
245 del self._len_to_seq[length]
246 self._lengths.remove(length)
250 def _remove_allocated_block(self, block):
252 blocks = self._allocated_blocks[arena]
256 self._discard_arena(arena)
258 def _free_pending_blocks(self):
262 block = self._pending_free_blocks.pop()
265 self._add_free_block(block)
266 self._remove_allocated_block(block)
268 def free(self, block):
271 # that it's called while self._lock is held: in that case,
272 # self._lock.acquire() would deadlock (issue #12352). To avoid that, a
278 if os.getpid() != self._lastpid:
281 os.getpid(),self._lastpid))
282 if not self._lock.acquire(False):
285 self._pending_free_blocks.append(block)
289 self._n_frees += 1
290 self._free_pending_blocks()
291 self._add_free_block(block)
292 self._remove_allocated_block(block)
294 self._lock.release()
296 def malloc(self, size):
302 if os.getpid() != self._lastpid:
303 self.__init__() # reinitialize after fork
304 with self._lock:
305 self._n_mallocs += 1
307 self._free_pending_blocks()
308 size = self._roundup(max(size, 1), self._alignment)
309 (arena, start, stop) = self._malloc(size)
314 self._add_free_block((arena, real_stop, stop))
315 self._allocated_blocks[arena].add((start, real_stop))
326 def __init__(self, size):
332 self._state = (block, size)
333 util.Finalize(self, BufferWrapper._heap.free, args=(block,))
335 def create_memoryview(self):
336 (arena, start, stop), size = self._state