o

;j�]�@shdZd
dl
mZmZmZmZ
ddlZddlmZ
gd�
Z	Gdd�d�Z
Gd	d
�d
�ZGdd�de�ZdS)
zlModule containing a memory memory manager which provides a sliding window on a number of memory mapped files�
)�	MapWindow�	MapRegion�
MapRegionList�	is_64_bit�N)
�reduce)�StaticWindowMapManager�SlidingWindowMapManager�WindowCursorc@s�eZ
dZd
ZdZd3dd�
Zdd�Zdd	�Zd
d�Zdd
�Z	dd�Z
dd�Zdd�Zd4dd�
Z
dd�Zdd�Zdd�Zdd�Zdd �Zd!d"�Zd#d$�Zd%d&�Zd'd(�Zd)d*�Zd+d,�Zd-d.�Zd/d0�Zd1d2�ZdS)5r
a�

    Pointer into the mapped region of the memory manager, keeping the map
    alive until it is destroyed and no other client uses it.

    Cursors should not be created manually, but are instead returned by the SlidingWindowMapManager

    **Note:**: The current implementation is suited for static and sliding window managers, but it also means
    that it must be suited for the somewhat quite different sliding manager. It could be improved, but
    I see no real need to do so.��_manager�_rlist�_region�_ofs�_sizeNcCs"|
|_||_
d|_d
|_d
|_dS)Nrr)�self�manager�regions�r�>/opt/saltstack/salt/lib/python3.10/site-packages/smmap/mman.py�__init__%s






zWindowCursor.__init__c

C�|��
dS�
N�
�_destroy�
rrrr�__del__,�
zWindowCursor.__del__c


Cs|Srrrrrr�	__enter__/s
zWindowCursor.__enter__cCrrr)r�exc_type�	exc_value�	tracebackrrr�__exit__2rzWindowCursor.__exit__c

	Cs^|��
|j
d
u
r-zt|j
�
dkr|jj�|j
���

Wd
SWd
Sttfy,


Yd
Swd
S)z&Destruction code to decrement countersNr)	�unuse_regionr
�lenr�_fdict�pop�
path_or_fd�	TypeError�KeyErrorrrrrr5s

���zWindowCursor._destroycCsb|
j|_t
|
j�
|
j�
|_|
j|_|
j|_|
j|_|jD]}|��
q|jd
u
r/|j��
d
Sd
S)z>Copy all data from rhs into this instance, handles usage countN)r�typer
rrr�increment_client_count)r�rhs�regionrrr�
_copy_fromJs








�zWindowCursor._copy_fromc
Cst|�
�}
|
�
|�

|
S)
zcopy module interface)r*r.)rZcpyrrr�__copy__Ys



zWindowCursor.__copy__cCs|��
|�
|
�

d
S)z�Assign rhs to this instance. This is required in order to get a real copy.
        Alternatively, you can copy an existing instance using the copy moduleN)rr.)rr,rrr�assign`s
zWindowCursor.assignrcCs�d
}|j}|j
��}t|p||��p|�}|jdu
r'|j�|
�
r#d}n|��
|
|kr-|S|r?|�|j
|
||d�|_|j�	�
|
|jj
|_t||j��|
�|_
|S)a$Assure we point to a window which allows access to the given offset into the file

        :param offset: absolute offset in bytes into the file
        :param size: amount of bytes to map. If 0, all available bytes will be mapped
        :param flags: additional flags to be given to os.open in case a file handle is initially opened
            for mapping. Has no effect if a region can actually be reused.
        :return: this instance - it should be queried for whether it points to a valid memory region.
            This is not the case if the mapping failed because we reached the end of the file

        **Note:**: The size actually mapped may be smaller than the given size. If that is the case,
        either the file has reached its end, or the map was created between two existing regionsTNF)rr
�	file_size�min�window_sizer�includes_ofsr#�_obtain_regionr+�_br�ofs_endr)r�offset�size�flagsZneed_regionZman�fsizerrr�
use_regionfs 











zWindowCursor.use_regionc

Cs |jd
u
r|j�
d�

d
|_d
S)a/
Unuse the current region. Does nothing if we have no current region

        **Note:** the cursor unuses the region automatically upon destruction. It is recommended
        to un-use the region once you are done reading from it in persistent cursors as it
        helps to free up resource more quicklyN���)rr+rrrrr#�s



zWindowCursor.unuse_regionc

Cs t|j
���
|j|j|j�S)
a�
Return a buffer object which allows access to our memory region from our offset
        to the window size. Please note that it might be smaller than you requested when calling use_region()

        **Note:** You can only obtain a buffer if this instance is_valid() !

        **Note:** buffers should not be cached passed the duration of your access as it will
        prevent resources from being freed even though they might not be accounted for anymore !)�
memoryviewr�bufferrrrrrrr?�s zWindowCursor.bufferc

C�
|j�
�S)
a

        :return: the underlying raw memory map. Please not that the offset and size is likely to be different
            to what you set as offset and size. Use it only if you are sure about the region it maps, which is the whole
            file in case of StaticWindowMapManager)r�maprrrrrA�s
zWindowCursor.mapc

C�
|jd
u
S)z2:return: True if we have a valid and usable regionN�
rrrrr�is_valid��
zWindowCursor.is_validc

CrB)z?:return: True if we are associated with a specific file alreadyN)
r
rrrr�
is_associated�rEzWindowCursor.is_associatedc

Cs|jj
|jS)
zh:return: offset to the first byte pointed to by our cursor

        **Note:** only if is_valid() is True)rr6rrrrr�	ofs_begin�szWindowCursor.ofs_beginc

Cs|jj
|j|jS)
z3:return: offset to one past the last available byte�rr6rrrrrrr7�szWindowCursor.ofs_endc


C�|jS)
z$:return: amount of bytes we point to)
rrrrrr9��zWindowCursor.sizec


CrI)
z�:return: our mapped region, or None if nothing is mapped yet
        :raise AssertionError: if we have no current region. This is only useful for debuggingrCrrrrr-�szWindowCursor.regioncCs2|jj
|j|
k
o|jj
|j|jkS
S)
z�:return: True if the given absolute offset is contained in the cursors
            current region

        **Note:** cursor must be valid for this to workrH)r�ofsrrrr4�s2zWindowCursor.includes_ofsc

Cr@)
z$:return: size of the underlying file)r
r1rrrrr1�rEzWindowCursor.file_sizec

Cr@)
z>:return: path or file descriptor of the underlying mapped file)r
r'rrrrr'�rEzWindowCursor.path_or_fdc

C�"t|j
��t�rtd
�
�
|j
��S)ze:return: path of the underlying mapped file
        :raise ValueError: if attached path is not a pathz>Path queried although mapping was applied to a file descriptor)�
isinstancer
r'�int�
ValueErrorrrrr�path�s

zWindowCursor.pathc

CrL)z�:return: file descriptor used to create the underlying mapping.

        **Note:** it is not required to be valid anymore
        :raise ValueError: if the mapping was not created by a file descriptorz@File descriptor queried although mapping was generated from path)rMr
r'�strrOrrrr�fd�s

zWindowCursor.fd)NN)rrr)�__name__�
__module__�__qualname__�__doc__�	__slots__rrrr"rr.r/r0r<r#r?rArDrFrGr7r9r-r4r1r'rPrRrrrrr
s4	

(
r
c@s�eZ
dZd
Zgd�
ZeZeZe	Z
eZdZ
ddejfdd�
Zdd�Zd	d
�Zdd�Zd
d�Zdd�Zdd�Zdd�Zdd�Zdd�Zdd�Zdd�ZdS)ra�
Provides a manager which will produce single size cursors that are allowed
    to always map the whole file.

    Clients must be written to specifically know that they are accessing their data
    through a StaticWindowMapManager, as they otherwise have to deal with their window size.

    These clients would have to use a SlidingWindowMapBuffer to hide this fact.

    This type will always use a maximum window size, and optimize certain methods to
    accommodate this fact)r%�_window_size�_max_memory_size�_max_handle_count�_memory_size�
_handle_countircCsrt�|_
|
|_||_||_d
|_d
|_|
d
kr$d}t�rd}||j|_|d
kr7d}t�r/d}||j|_dSdS)a�initialize the manager with the given parameters.
        :param window_size: if -1, a default window size will be chosen depending on
            the operating system's architecture. It will internally be quantified to a multiple of the page size
            If 0, the window may have any size, which basically results in mapping the whole file at one
        :param max_memory_size: maximum amount of memory we may map at once before releasing mapped regions.
            If 0, a viable default will be set depending on the system's architecture.
            It is a soft limit that is tried to be kept, but nothing bad happens if we have to over-allocate
        :param max_open_handles: if not maxint, limit the amount of open file handles to the given number.
            Otherwise the amount is only limited by the system itself. If a system or soft limit is hit,
            the manager will free as many handles as possibler�@ii N)	�dictr%rXrYrZr[r\r�_MB_in_bytes)rr3�max_memory_size�max_open_handlesZcoeffrrrr
s"










�zStaticWindowMapManager.__init__cCs�d
}|
d
ks|j|
|j
kred}d}|j��D]}|D]}|��dkr1|dus-|j|jkr1|}|}qq|dur:	|S|d7}||�|�
=|�d�

|j|��8_|j	d8_	|
d
ks|j|
|j
ks|S)amUnmap the region which was least-recently used and has no client
        :param size: size of the region we want to map next (assuming its not already mapped partially or full
            if 0, we try to free any available region
        :return: Amount of freed regions

        .. Note::
            We don't raise exceptions anymore, in order to keep the system working, allowing temporary overallocation.
            If the system runs out of memory, it will tell.

        .. TODO::
            implement a case where all unusued regions are discarded efficiently.
            Currently its only brute force
        rNr
r=)
r[rYr%�valuesZclient_countZ_uc�indexr+r9r\)rr9Z	num_foundZ
lru_regionZlru_listrr-rrr�_collect_lru_region/
s,







��

	�




�z*StaticWindowMapManager._collect_lru_regionc
Cs�|j||j
kr
|�|�

d
}|
rt|
�
dksJ�
|
d}n=z
|�|
��dtj|�}WntyE


|r5�|�d�

|�	|
|||d�YSw|j
d7_
|j|��7_|
�|�

|�
|�
sbJ�
|S)z�Utility to create a new region - for more information on the parameters,
        see MapCursor.use_region.
        :param a: A regions (a)rray
        :return: The newly created regionNr
rT)r[rYrdr$�MapRegionClsr'�sys�maxsize�	Exceptionr5r\r9�appendr4)r�
ar8r9r:�is_recursive�
rrrrr5X
s&









�



z%StaticWindowMapManager._obtain_regioncCs4|j�
|
�
}|d
ur|�|
�
}||j|
<|�||�S)a�
        :return: a cursor pointing to the given path or file descriptor.
            It can be used to map new regions of the file into memory

        **Note:** if a file descriptor is given, it is assumed to be open and valid,
        but may be closed afterwards. To refer to the same file, you may reuse
        your existing file descriptor, but keep in mind that new windows can only
        be mapped as long as it stays valid. This is why the using actual file paths
        are preferred unless you plan to keep the file descriptor open.

        **Note:** file descriptors are problematic as they are not necessarily unique, as two
        different files opened and closed in succession might have the same file descriptor id.

        **Note:** Using file descriptors directly is faster once new windows are mapped as it
        prevents the file to be opened again just for the purpose of mapping it.N)r%�get�MapRegionListCls�WindowCursorCls)rr'rrrr�make_cursor�
s





z"StaticWindowMapManager.make_cursorc

Cs
|�d
�
S)z]Collect all available free-to-collect mapped regions
        :return: Amount of freed handlesr)
rdrrrr�collect�
s
zStaticWindowMapManager.collectc


CrI)
zO:return: amount of file handles in use. Each mapped region uses one file handle)
r\rrrr�num_file_handles�
rJz'StaticWindowMapManager.num_file_handlesc

Cs td
d�dd�|j
��D�
d�S)z$Amount of opened files in the systemcSs||
Srr)�
x�
yrrr�<lambda>�
sz7StaticWindowMapManager.num_open_files.<locals>.<lambda>c
ss �|]}
t|
�
dkrd
V
qdS)rr
N)
r$)�.0�rlistrrr�	<genexpr>�
s�z8StaticWindowMapManager.num_open_files.<locals>.<genexpr>r)rr%rbrrrr�num_open_files�
s z%StaticWindowMapManager.num_open_filesc


CrI)
z8:return: size of each window when allocating new regions)
rXrrrrr3�
rJz"StaticWindowMapManager.window_sizec


CrI)
z2:return: amount of bytes currently mapped in total)
r[rrrr�mapped_memory_size�
rJz)StaticWindowMapManager.mapped_memory_sizec


CrI)
z5:return: maximum amount of handles we may have opened)
rZrrrr�max_file_handles�
rJz'StaticWindowMapManager.max_file_handlesc


CrI)
z1:return: maximum amount of memory we may allocate)
rYrrrr�max_mapped_memory_size�
rJz-StaticWindowMapManager.max_mapped_memory_sizecCsNtj
d
krdSd}|j��D]\}}|�|
�
r$|D]
}|��
|d7}qq|S)a�ONLY AVAILABLE ON WINDOWS
        On windows removing files is not allowed if anybody still has it opened.
        If this process is ourselves, and if the whole process uses this memory
        manager (as far as the parent framework is concerned) we can enforce
        closing all memory maps whose path matches the given base path to
        allow the respective operation after all.
        The respective system must NOT access the closed memory regions anymore !
        This really may only be used if you know that the items which keep
        the cursors alive will not be using it anymore. They need to be recreated !
        :return: Amount of closed handles

        **Note:** does nothing on non-windows platforms�win32Nrr
)rf�platformr%�items�
startswith�release)r�	base_pathZ
num_closedrPrwr-rrr�force_map_handle_removal_win�
s









�z3StaticWindowMapManager.force_map_handle_removal_winN)rSrTrUrVrWrrnr�MapWindowClsrrer
ror_rfrgrrdr5rprqrrryr3rzr{r|r�rrrrr�s(



$))rcs8eZ
dZd
Ze�Zddejf�f
dd�	Zdd�Z	�Z
S)r	a�Maintains a list of ranges of mapped memory regions in one or more files and allows to easily
    obtain additional regions assuring there is no overlap.
    Once a certain memory limit is reached globally, or if there cannot be more open file handles
    which result from each mmap call, the least recently used, and currently unused mapped regions
    are unloaded automatically.

    **Note:** currently not thread-safe !

    **Note:** in the current implementation, we will automatically unload windows if we either cannot
        create more memory maps (as the open file handles limit is hit) or if we have allocated more than
        a safe amount of memory already, which would possibly cause memory allocations to fail as our address
        space is full.r=rcst��
|
||�
d
S)z%Adjusts the default window size to -1N)�superr)rr3r`ra�
�	__class__rrr�
sz SlidingWindowMapManager.__init__c
Csd}d
}t|
�
}||kr2||d}	|
|	j
}
|
|k
r,|
|	�|�
r'|
|	}n|	d}n|	}||ks|du�
r
|j}|�d
d
�}|�||�}	|�|
��d
�}
|j||jkr[|�|�

d
}t|
�
}|dkro|
d
j
|k
rnd}n|}t	|
�
D]
\}}|j
|kr�|}
n
qu|d
kr�|r�|j�
|
|�
}
n||kr�|j�
|
|�
}
|j�
|
|d�
}|	�||�
|	�|
|�
|	�
�
|	��|
jkr�|
j|	j|	_z|j|jkr�t�
|�|
��|	j|	j|�}Wnty�


|r�|�d
�

|�|
|||d�YSw|jd7_|j|��7_|
�||�
|S)Nr�r
T)r$r6r4rXr�r1r[rYrd�	enumerateZfrom_regionZextend_left_toZextend_right_toZalignr7rKr9r\rZrhrer'r5�insert)rrjr8r9r:rkrl�lo�hiZmidrKr3�left�rightZ
insert_posZlen_regions�
ir-rrrr5�
st










�










�




�	

�








�

z&SlidingWindowMapManager._obtain_region)rSrTrUrV�tuplerWrfrgrr5�
__classcell__rrr�rr	�
s

r	)
rV�utilrrrrrf�	functoolsr�__all__r
rr	rrrr�<module>
s

[k