LockTree library, originally from PerconaFT (#7753)
Summary: To be used for implementing Range Locking. Pull Request resolved: https://github.com/facebook/rocksdb/pull/7753 Reviewed By: zhichao-cao Differential Revision: D25378980 Pulled By: cheng-chang fbshipit-source-id: 801a9c5cd92a84654ca2586b73e8f69001e89320main
Sergei Petrunia
4 years ago
committed by
Facebook GitHub Bot
parent
7b2216c906
commit
98236fb10e
@ -0,0 +1,661 @@ |
||||
GNU AFFERO GENERAL PUBLIC LICENSE |
||||
Version 3, 19 November 2007 |
||||
|
||||
Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/> |
||||
Everyone is permitted to copy and distribute verbatim copies |
||||
of this license document, but changing it is not allowed. |
||||
|
||||
Preamble |
||||
|
||||
The GNU Affero General Public License is a free, copyleft license for |
||||
software and other kinds of works, specifically designed to ensure |
||||
cooperation with the community in the case of network server software. |
||||
|
||||
The licenses for most software and other practical works are designed |
||||
to take away your freedom to share and change the works. By contrast, |
||||
our General Public Licenses are intended to guarantee your freedom to |
||||
share and change all versions of a program--to make sure it remains free |
||||
software for all its users. |
||||
|
||||
When we speak of free software, we are referring to freedom, not |
||||
price. Our General Public Licenses are designed to make sure that you |
||||
have the freedom to distribute copies of free software (and charge for |
||||
them if you wish), that you receive source code or can get it if you |
||||
want it, that you can change the software or use pieces of it in new |
||||
free programs, and that you know you can do these things. |
||||
|
||||
Developers that use our General Public Licenses protect your rights |
||||
with two steps: (1) assert copyright on the software, and (2) offer |
||||
you this License which gives you legal permission to copy, distribute |
||||
and/or modify the software. |
||||
|
||||
A secondary benefit of defending all users' freedom is that |
||||
improvements made in alternate versions of the program, if they |
||||
receive widespread use, become available for other developers to |
||||
incorporate. Many developers of free software are heartened and |
||||
encouraged by the resulting cooperation. However, in the case of |
||||
software used on network servers, this result may fail to come about. |
||||
The GNU General Public License permits making a modified version and |
||||
letting the public access it on a server without ever releasing its |
||||
source code to the public. |
||||
|
||||
The GNU Affero General Public License is designed specifically to |
||||
ensure that, in such cases, the modified source code becomes available |
||||
to the community. It requires the operator of a network server to |
||||
provide the source code of the modified version running there to the |
||||
users of that server. Therefore, public use of a modified version, on |
||||
a publicly accessible server, gives the public access to the source |
||||
code of the modified version. |
||||
|
||||
An older license, called the Affero General Public License and |
||||
published by Affero, was designed to accomplish similar goals. This is |
||||
a different license, not a version of the Affero GPL, but Affero has |
||||
released a new version of the Affero GPL which permits relicensing under |
||||
this license. |
||||
|
||||
The precise terms and conditions for copying, distribution and |
||||
modification follow. |
||||
|
||||
TERMS AND CONDITIONS |
||||
|
||||
0. Definitions. |
||||
|
||||
"This License" refers to version 3 of the GNU Affero General Public License. |
||||
|
||||
"Copyright" also means copyright-like laws that apply to other kinds of |
||||
works, such as semiconductor masks. |
||||
|
||||
"The Program" refers to any copyrightable work licensed under this |
||||
License. Each licensee is addressed as "you". "Licensees" and |
||||
"recipients" may be individuals or organizations. |
||||
|
||||
To "modify" a work means to copy from or adapt all or part of the work |
||||
in a fashion requiring copyright permission, other than the making of an |
||||
exact copy. The resulting work is called a "modified version" of the |
||||
earlier work or a work "based on" the earlier work. |
||||
|
||||
A "covered work" means either the unmodified Program or a work based |
||||
on the Program. |
||||
|
||||
To "propagate" a work means to do anything with it that, without |
||||
permission, would make you directly or secondarily liable for |
||||
infringement under applicable copyright law, except executing it on a |
||||
computer or modifying a private copy. Propagation includes copying, |
||||
distribution (with or without modification), making available to the |
||||
public, and in some countries other activities as well. |
||||
|
||||
To "convey" a work means any kind of propagation that enables other |
||||
parties to make or receive copies. Mere interaction with a user through |
||||
a computer network, with no transfer of a copy, is not conveying. |
||||
|
||||
An interactive user interface displays "Appropriate Legal Notices" |
||||
to the extent that it includes a convenient and prominently visible |
||||
feature that (1) displays an appropriate copyright notice, and (2) |
||||
tells the user that there is no warranty for the work (except to the |
||||
extent that warranties are provided), that licensees may convey the |
||||
work under this License, and how to view a copy of this License. If |
||||
the interface presents a list of user commands or options, such as a |
||||
menu, a prominent item in the list meets this criterion. |
||||
|
||||
1. Source Code. |
||||
|
||||
The "source code" for a work means the preferred form of the work |
||||
for making modifications to it. "Object code" means any non-source |
||||
form of a work. |
||||
|
||||
A "Standard Interface" means an interface that either is an official |
||||
standard defined by a recognized standards body, or, in the case of |
||||
interfaces specified for a particular programming language, one that |
||||
is widely used among developers working in that language. |
||||
|
||||
The "System Libraries" of an executable work include anything, other |
||||
than the work as a whole, that (a) is included in the normal form of |
||||
packaging a Major Component, but which is not part of that Major |
||||
Component, and (b) serves only to enable use of the work with that |
||||
Major Component, or to implement a Standard Interface for which an |
||||
implementation is available to the public in source code form. A |
||||
"Major Component", in this context, means a major essential component |
||||
(kernel, window system, and so on) of the specific operating system |
||||
(if any) on which the executable work runs, or a compiler used to |
||||
produce the work, or an object code interpreter used to run it. |
||||
|
||||
The "Corresponding Source" for a work in object code form means all |
||||
the source code needed to generate, install, and (for an executable |
||||
work) run the object code and to modify the work, including scripts to |
||||
control those activities. However, it does not include the work's |
||||
System Libraries, or general-purpose tools or generally available free |
||||
programs which are used unmodified in performing those activities but |
||||
which are not part of the work. For example, Corresponding Source |
||||
includes interface definition files associated with source files for |
||||
the work, and the source code for shared libraries and dynamically |
||||
linked subprograms that the work is specifically designed to require, |
||||
such as by intimate data communication or control flow between those |
||||
subprograms and other parts of the work. |
||||
|
||||
The Corresponding Source need not include anything that users |
||||
can regenerate automatically from other parts of the Corresponding |
||||
Source. |
||||
|
||||
The Corresponding Source for a work in source code form is that |
||||
same work. |
||||
|
||||
2. Basic Permissions. |
||||
|
||||
All rights granted under this License are granted for the term of |
||||
copyright on the Program, and are irrevocable provided the stated |
||||
conditions are met. This License explicitly affirms your unlimited |
||||
permission to run the unmodified Program. The output from running a |
||||
covered work is covered by this License only if the output, given its |
||||
content, constitutes a covered work. This License acknowledges your |
||||
rights of fair use or other equivalent, as provided by copyright law. |
||||
|
||||
You may make, run and propagate covered works that you do not |
||||
convey, without conditions so long as your license otherwise remains |
||||
in force. You may convey covered works to others for the sole purpose |
||||
of having them make modifications exclusively for you, or provide you |
||||
with facilities for running those works, provided that you comply with |
||||
the terms of this License in conveying all material for which you do |
||||
not control copyright. Those thus making or running the covered works |
||||
for you must do so exclusively on your behalf, under your direction |
||||
and control, on terms that prohibit them from making any copies of |
||||
your copyrighted material outside their relationship with you. |
||||
|
||||
Conveying under any other circumstances is permitted solely under |
||||
the conditions stated below. Sublicensing is not allowed; section 10 |
||||
makes it unnecessary. |
||||
|
||||
3. Protecting Users' Legal Rights From Anti-Circumvention Law. |
||||
|
||||
No covered work shall be deemed part of an effective technological |
||||
measure under any applicable law fulfilling obligations under article |
||||
11 of the WIPO copyright treaty adopted on 20 December 1996, or |
||||
similar laws prohibiting or restricting circumvention of such |
||||
measures. |
||||
|
||||
When you convey a covered work, you waive any legal power to forbid |
||||
circumvention of technological measures to the extent such circumvention |
||||
is effected by exercising rights under this License with respect to |
||||
the covered work, and you disclaim any intention to limit operation or |
||||
modification of the work as a means of enforcing, against the work's |
||||
users, your or third parties' legal rights to forbid circumvention of |
||||
technological measures. |
||||
|
||||
4. Conveying Verbatim Copies. |
||||
|
||||
You may convey verbatim copies of the Program's source code as you |
||||
receive it, in any medium, provided that you conspicuously and |
||||
appropriately publish on each copy an appropriate copyright notice; |
||||
keep intact all notices stating that this License and any |
||||
non-permissive terms added in accord with section 7 apply to the code; |
||||
keep intact all notices of the absence of any warranty; and give all |
||||
recipients a copy of this License along with the Program. |
||||
|
||||
You may charge any price or no price for each copy that you convey, |
||||
and you may offer support or warranty protection for a fee. |
||||
|
||||
5. Conveying Modified Source Versions. |
||||
|
||||
You may convey a work based on the Program, or the modifications to |
||||
produce it from the Program, in the form of source code under the |
||||
terms of section 4, provided that you also meet all of these conditions: |
||||
|
||||
a) The work must carry prominent notices stating that you modified |
||||
it, and giving a relevant date. |
||||
|
||||
b) The work must carry prominent notices stating that it is |
||||
released under this License and any conditions added under section |
||||
7. This requirement modifies the requirement in section 4 to |
||||
"keep intact all notices". |
||||
|
||||
c) You must license the entire work, as a whole, under this |
||||
License to anyone who comes into possession of a copy. This |
||||
License will therefore apply, along with any applicable section 7 |
||||
additional terms, to the whole of the work, and all its parts, |
||||
regardless of how they are packaged. This License gives no |
||||
permission to license the work in any other way, but it does not |
||||
invalidate such permission if you have separately received it. |
||||
|
||||
d) If the work has interactive user interfaces, each must display |
||||
Appropriate Legal Notices; however, if the Program has interactive |
||||
interfaces that do not display Appropriate Legal Notices, your |
||||
work need not make them do so. |
||||
|
||||
A compilation of a covered work with other separate and independent |
||||
works, which are not by their nature extensions of the covered work, |
||||
and which are not combined with it such as to form a larger program, |
||||
in or on a volume of a storage or distribution medium, is called an |
||||
"aggregate" if the compilation and its resulting copyright are not |
||||
used to limit the access or legal rights of the compilation's users |
||||
beyond what the individual works permit. Inclusion of a covered work |
||||
in an aggregate does not cause this License to apply to the other |
||||
parts of the aggregate. |
||||
|
||||
6. Conveying Non-Source Forms. |
||||
|
||||
You may convey a covered work in object code form under the terms |
||||
of sections 4 and 5, provided that you also convey the |
||||
machine-readable Corresponding Source under the terms of this License, |
||||
in one of these ways: |
||||
|
||||
a) Convey the object code in, or embodied in, a physical product |
||||
(including a physical distribution medium), accompanied by the |
||||
Corresponding Source fixed on a durable physical medium |
||||
customarily used for software interchange. |
||||
|
||||
b) Convey the object code in, or embodied in, a physical product |
||||
(including a physical distribution medium), accompanied by a |
||||
written offer, valid for at least three years and valid for as |
||||
long as you offer spare parts or customer support for that product |
||||
model, to give anyone who possesses the object code either (1) a |
||||
copy of the Corresponding Source for all the software in the |
||||
product that is covered by this License, on a durable physical |
||||
medium customarily used for software interchange, for a price no |
||||
more than your reasonable cost of physically performing this |
||||
conveying of source, or (2) access to copy the |
||||
Corresponding Source from a network server at no charge. |
||||
|
||||
c) Convey individual copies of the object code with a copy of the |
||||
written offer to provide the Corresponding Source. This |
||||
alternative is allowed only occasionally and noncommercially, and |
||||
only if you received the object code with such an offer, in accord |
||||
with subsection 6b. |
||||
|
||||
d) Convey the object code by offering access from a designated |
||||
place (gratis or for a charge), and offer equivalent access to the |
||||
Corresponding Source in the same way through the same place at no |
||||
further charge. You need not require recipients to copy the |
||||
Corresponding Source along with the object code. If the place to |
||||
copy the object code is a network server, the Corresponding Source |
||||
may be on a different server (operated by you or a third party) |
||||
that supports equivalent copying facilities, provided you maintain |
||||
clear directions next to the object code saying where to find the |
||||
Corresponding Source. Regardless of what server hosts the |
||||
Corresponding Source, you remain obligated to ensure that it is |
||||
available for as long as needed to satisfy these requirements. |
||||
|
||||
e) Convey the object code using peer-to-peer transmission, provided |
||||
you inform other peers where the object code and Corresponding |
||||
Source of the work are being offered to the general public at no |
||||
charge under subsection 6d. |
||||
|
||||
A separable portion of the object code, whose source code is excluded |
||||
from the Corresponding Source as a System Library, need not be |
||||
included in conveying the object code work. |
||||
|
||||
A "User Product" is either (1) a "consumer product", which means any |
||||
tangible personal property which is normally used for personal, family, |
||||
or household purposes, or (2) anything designed or sold for incorporation |
||||
into a dwelling. In determining whether a product is a consumer product, |
||||
doubtful cases shall be resolved in favor of coverage. For a particular |
||||
product received by a particular user, "normally used" refers to a |
||||
typical or common use of that class of product, regardless of the status |
||||
of the particular user or of the way in which the particular user |
||||
actually uses, or expects or is expected to use, the product. A product |
||||
is a consumer product regardless of whether the product has substantial |
||||
commercial, industrial or non-consumer uses, unless such uses represent |
||||
the only significant mode of use of the product. |
||||
|
||||
"Installation Information" for a User Product means any methods, |
||||
procedures, authorization keys, or other information required to install |
||||
and execute modified versions of a covered work in that User Product from |
||||
a modified version of its Corresponding Source. The information must |
||||
suffice to ensure that the continued functioning of the modified object |
||||
code is in no case prevented or interfered with solely because |
||||
modification has been made. |
||||
|
||||
If you convey an object code work under this section in, or with, or |
||||
specifically for use in, a User Product, and the conveying occurs as |
||||
part of a transaction in which the right of possession and use of the |
||||
User Product is transferred to the recipient in perpetuity or for a |
||||
fixed term (regardless of how the transaction is characterized), the |
||||
Corresponding Source conveyed under this section must be accompanied |
||||
by the Installation Information. But this requirement does not apply |
||||
if neither you nor any third party retains the ability to install |
||||
modified object code on the User Product (for example, the work has |
||||
been installed in ROM). |
||||
|
||||
The requirement to provide Installation Information does not include a |
||||
requirement to continue to provide support service, warranty, or updates |
||||
for a work that has been modified or installed by the recipient, or for |
||||
the User Product in which it has been modified or installed. Access to a |
||||
network may be denied when the modification itself materially and |
||||
adversely affects the operation of the network or violates the rules and |
||||
protocols for communication across the network. |
||||
|
||||
Corresponding Source conveyed, and Installation Information provided, |
||||
in accord with this section must be in a format that is publicly |
||||
documented (and with an implementation available to the public in |
||||
source code form), and must require no special password or key for |
||||
unpacking, reading or copying. |
||||
|
||||
7. Additional Terms. |
||||
|
||||
"Additional permissions" are terms that supplement the terms of this |
||||
License by making exceptions from one or more of its conditions. |
||||
Additional permissions that are applicable to the entire Program shall |
||||
be treated as though they were included in this License, to the extent |
||||
that they are valid under applicable law. If additional permissions |
||||
apply only to part of the Program, that part may be used separately |
||||
under those permissions, but the entire Program remains governed by |
||||
this License without regard to the additional permissions. |
||||
|
||||
When you convey a copy of a covered work, you may at your option |
||||
remove any additional permissions from that copy, or from any part of |
||||
it. (Additional permissions may be written to require their own |
||||
removal in certain cases when you modify the work.) You may place |
||||
additional permissions on material, added by you to a covered work, |
||||
for which you have or can give appropriate copyright permission. |
||||
|
||||
Notwithstanding any other provision of this License, for material you |
||||
add to a covered work, you may (if authorized by the copyright holders of |
||||
that material) supplement the terms of this License with terms: |
||||
|
||||
a) Disclaiming warranty or limiting liability differently from the |
||||
terms of sections 15 and 16 of this License; or |
||||
|
||||
b) Requiring preservation of specified reasonable legal notices or |
||||
author attributions in that material or in the Appropriate Legal |
||||
Notices displayed by works containing it; or |
||||
|
||||
c) Prohibiting misrepresentation of the origin of that material, or |
||||
requiring that modified versions of such material be marked in |
||||
reasonable ways as different from the original version; or |
||||
|
||||
d) Limiting the use for publicity purposes of names of licensors or |
||||
authors of the material; or |
||||
|
||||
e) Declining to grant rights under trademark law for use of some |
||||
trade names, trademarks, or service marks; or |
||||
|
||||
f) Requiring indemnification of licensors and authors of that |
||||
material by anyone who conveys the material (or modified versions of |
||||
it) with contractual assumptions of liability to the recipient, for |
||||
any liability that these contractual assumptions directly impose on |
||||
those licensors and authors. |
||||
|
||||
All other non-permissive additional terms are considered "further |
||||
restrictions" within the meaning of section 10. If the Program as you |
||||
received it, or any part of it, contains a notice stating that it is |
||||
governed by this License along with a term that is a further |
||||
restriction, you may remove that term. If a license document contains |
||||
a further restriction but permits relicensing or conveying under this |
||||
License, you may add to a covered work material governed by the terms |
||||
of that license document, provided that the further restriction does |
||||
not survive such relicensing or conveying. |
||||
|
||||
If you add terms to a covered work in accord with this section, you |
||||
must place, in the relevant source files, a statement of the |
||||
additional terms that apply to those files, or a notice indicating |
||||
where to find the applicable terms. |
||||
|
||||
Additional terms, permissive or non-permissive, may be stated in the |
||||
form of a separately written license, or stated as exceptions; |
||||
the above requirements apply either way. |
||||
|
||||
8. Termination. |
||||
|
||||
You may not propagate or modify a covered work except as expressly |
||||
provided under this License. Any attempt otherwise to propagate or |
||||
modify it is void, and will automatically terminate your rights under |
||||
this License (including any patent licenses granted under the third |
||||
paragraph of section 11). |
||||
|
||||
However, if you cease all violation of this License, then your |
||||
license from a particular copyright holder is reinstated (a) |
||||
provisionally, unless and until the copyright holder explicitly and |
||||
finally terminates your license, and (b) permanently, if the copyright |
||||
holder fails to notify you of the violation by some reasonable means |
||||
prior to 60 days after the cessation. |
||||
|
||||
Moreover, your license from a particular copyright holder is |
||||
reinstated permanently if the copyright holder notifies you of the |
||||
violation by some reasonable means, this is the first time you have |
||||
received notice of violation of this License (for any work) from that |
||||
copyright holder, and you cure the violation prior to 30 days after |
||||
your receipt of the notice. |
||||
|
||||
Termination of your rights under this section does not terminate the |
||||
licenses of parties who have received copies or rights from you under |
||||
this License. If your rights have been terminated and not permanently |
||||
reinstated, you do not qualify to receive new licenses for the same |
||||
material under section 10. |
||||
|
||||
9. Acceptance Not Required for Having Copies. |
||||
|
||||
You are not required to accept this License in order to receive or |
||||
run a copy of the Program. Ancillary propagation of a covered work |
||||
occurring solely as a consequence of using peer-to-peer transmission |
||||
to receive a copy likewise does not require acceptance. However, |
||||
nothing other than this License grants you permission to propagate or |
||||
modify any covered work. These actions infringe copyright if you do |
||||
not accept this License. Therefore, by modifying or propagating a |
||||
covered work, you indicate your acceptance of this License to do so. |
||||
|
||||
10. Automatic Licensing of Downstream Recipients. |
||||
|
||||
Each time you convey a covered work, the recipient automatically |
||||
receives a license from the original licensors, to run, modify and |
||||
propagate that work, subject to this License. You are not responsible |
||||
for enforcing compliance by third parties with this License. |
||||
|
||||
An "entity transaction" is a transaction transferring control of an |
||||
organization, or substantially all assets of one, or subdividing an |
||||
organization, or merging organizations. If propagation of a covered |
||||
work results from an entity transaction, each party to that |
||||
transaction who receives a copy of the work also receives whatever |
||||
licenses to the work the party's predecessor in interest had or could |
||||
give under the previous paragraph, plus a right to possession of the |
||||
Corresponding Source of the work from the predecessor in interest, if |
||||
the predecessor has it or can get it with reasonable efforts. |
||||
|
||||
You may not impose any further restrictions on the exercise of the |
||||
rights granted or affirmed under this License. For example, you may |
||||
not impose a license fee, royalty, or other charge for exercise of |
||||
rights granted under this License, and you may not initiate litigation |
||||
(including a cross-claim or counterclaim in a lawsuit) alleging that |
||||
any patent claim is infringed by making, using, selling, offering for |
||||
sale, or importing the Program or any portion of it. |
||||
|
||||
11. Patents. |
||||
|
||||
A "contributor" is a copyright holder who authorizes use under this |
||||
License of the Program or a work on which the Program is based. The |
||||
work thus licensed is called the contributor's "contributor version". |
||||
|
||||
A contributor's "essential patent claims" are all patent claims |
||||
owned or controlled by the contributor, whether already acquired or |
||||
hereafter acquired, that would be infringed by some manner, permitted |
||||
by this License, of making, using, or selling its contributor version, |
||||
but do not include claims that would be infringed only as a |
||||
consequence of further modification of the contributor version. For |
||||
purposes of this definition, "control" includes the right to grant |
||||
patent sublicenses in a manner consistent with the requirements of |
||||
this License. |
||||
|
||||
Each contributor grants you a non-exclusive, worldwide, royalty-free |
||||
patent license under the contributor's essential patent claims, to |
||||
make, use, sell, offer for sale, import and otherwise run, modify and |
||||
propagate the contents of its contributor version. |
||||
|
||||
In the following three paragraphs, a "patent license" is any express |
||||
agreement or commitment, however denominated, not to enforce a patent |
||||
(such as an express permission to practice a patent or covenant not to |
||||
sue for patent infringement). To "grant" such a patent license to a |
||||
party means to make such an agreement or commitment not to enforce a |
||||
patent against the party. |
||||
|
||||
If you convey a covered work, knowingly relying on a patent license, |
||||
and the Corresponding Source of the work is not available for anyone |
||||
to copy, free of charge and under the terms of this License, through a |
||||
publicly available network server or other readily accessible means, |
||||
then you must either (1) cause the Corresponding Source to be so |
||||
available, or (2) arrange to deprive yourself of the benefit of the |
||||
patent license for this particular work, or (3) arrange, in a manner |
||||
consistent with the requirements of this License, to extend the patent |
||||
license to downstream recipients. "Knowingly relying" means you have |
||||
actual knowledge that, but for the patent license, your conveying the |
||||
covered work in a country, or your recipient's use of the covered work |
||||
in a country, would infringe one or more identifiable patents in that |
||||
country that you have reason to believe are valid. |
||||
|
||||
If, pursuant to or in connection with a single transaction or |
||||
arrangement, you convey, or propagate by procuring conveyance of, a |
||||
covered work, and grant a patent license to some of the parties |
||||
receiving the covered work authorizing them to use, propagate, modify |
||||
or convey a specific copy of the covered work, then the patent license |
||||
you grant is automatically extended to all recipients of the covered |
||||
work and works based on it. |
||||
|
||||
A patent license is "discriminatory" if it does not include within |
||||
the scope of its coverage, prohibits the exercise of, or is |
||||
conditioned on the non-exercise of one or more of the rights that are |
||||
specifically granted under this License. You may not convey a covered |
||||
work if you are a party to an arrangement with a third party that is |
||||
in the business of distributing software, under which you make payment |
||||
to the third party based on the extent of your activity of conveying |
||||
the work, and under which the third party grants, to any of the |
||||
parties who would receive the covered work from you, a discriminatory |
||||
patent license (a) in connection with copies of the covered work |
||||
conveyed by you (or copies made from those copies), or (b) primarily |
||||
for and in connection with specific products or compilations that |
||||
contain the covered work, unless you entered into that arrangement, |
||||
or that patent license was granted, prior to 28 March 2007. |
||||
|
||||
Nothing in this License shall be construed as excluding or limiting |
||||
any implied license or other defenses to infringement that may |
||||
otherwise be available to you under applicable patent law. |
||||
|
||||
12. No Surrender of Others' Freedom. |
||||
|
||||
If conditions are imposed on you (whether by court order, agreement or |
||||
otherwise) that contradict the conditions of this License, they do not |
||||
excuse you from the conditions of this License. If you cannot convey a |
||||
covered work so as to satisfy simultaneously your obligations under this |
||||
License and any other pertinent obligations, then as a consequence you may |
||||
not convey it at all. For example, if you agree to terms that obligate you |
||||
to collect a royalty for further conveying from those to whom you convey |
||||
the Program, the only way you could satisfy both those terms and this |
||||
License would be to refrain entirely from conveying the Program. |
||||
|
||||
13. Remote Network Interaction; Use with the GNU General Public License. |
||||
|
||||
Notwithstanding any other provision of this License, if you modify the |
||||
Program, your modified version must prominently offer all users |
||||
interacting with it remotely through a computer network (if your version |
||||
supports such interaction) an opportunity to receive the Corresponding |
||||
Source of your version by providing access to the Corresponding Source |
||||
from a network server at no charge, through some standard or customary |
||||
means of facilitating copying of software. This Corresponding Source |
||||
shall include the Corresponding Source for any work covered by version 3 |
||||
of the GNU General Public License that is incorporated pursuant to the |
||||
following paragraph. |
||||
|
||||
Notwithstanding any other provision of this License, you have |
||||
permission to link or combine any covered work with a work licensed |
||||
under version 3 of the GNU General Public License into a single |
||||
combined work, and to convey the resulting work. The terms of this |
||||
License will continue to apply to the part which is the covered work, |
||||
but the work with which it is combined will remain governed by version |
||||
3 of the GNU General Public License. |
||||
|
||||
14. Revised Versions of this License. |
||||
|
||||
The Free Software Foundation may publish revised and/or new versions of |
||||
the GNU Affero General Public License from time to time. Such new versions |
||||
will be similar in spirit to the present version, but may differ in detail to |
||||
address new problems or concerns. |
||||
|
||||
Each version is given a distinguishing version number. If the |
||||
Program specifies that a certain numbered version of the GNU Affero General |
||||
Public License "or any later version" applies to it, you have the |
||||
option of following the terms and conditions either of that numbered |
||||
version or of any later version published by the Free Software |
||||
Foundation. If the Program does not specify a version number of the |
||||
GNU Affero General Public License, you may choose any version ever published |
||||
by the Free Software Foundation. |
||||
|
||||
If the Program specifies that a proxy can decide which future |
||||
versions of the GNU Affero General Public License can be used, that proxy's |
||||
public statement of acceptance of a version permanently authorizes you |
||||
to choose that version for the Program. |
||||
|
||||
Later license versions may give you additional or different |
||||
permissions. However, no additional obligations are imposed on any |
||||
author or copyright holder as a result of your choosing to follow a |
||||
later version. |
||||
|
||||
15. Disclaimer of Warranty. |
||||
|
||||
THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY |
||||
APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT |
||||
HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY |
||||
OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, |
||||
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
||||
PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM |
||||
IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF |
||||
ALL NECESSARY SERVICING, REPAIR OR CORRECTION. |
||||
|
||||
16. Limitation of Liability. |
||||
|
||||
IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING |
||||
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS |
||||
THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY |
||||
GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE |
||||
USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF |
||||
DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD |
||||
PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), |
||||
EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF |
||||
SUCH DAMAGES. |
||||
|
||||
17. Interpretation of Sections 15 and 16. |
||||
|
||||
If the disclaimer of warranty and limitation of liability provided |
||||
above cannot be given local legal effect according to their terms, |
||||
reviewing courts shall apply local law that most closely approximates |
||||
an absolute waiver of all civil liability in connection with the |
||||
Program, unless a warranty or assumption of liability accompanies a |
||||
copy of the Program in return for a fee. |
||||
|
||||
END OF TERMS AND CONDITIONS |
||||
|
||||
How to Apply These Terms to Your New Programs |
||||
|
||||
If you develop a new program, and you want it to be of the greatest |
||||
possible use to the public, the best way to achieve this is to make it |
||||
free software which everyone can redistribute and change under these terms. |
||||
|
||||
To do so, attach the following notices to the program. It is safest |
||||
to attach them to the start of each source file to most effectively |
||||
state the exclusion of warranty; and each file should have at least |
||||
the "copyright" line and a pointer to where the full notice is found. |
||||
|
||||
<one line to give the program's name and a brief idea of what it does.> |
||||
Copyright (C) <year> <name of author> |
||||
|
||||
This program is free software: you can redistribute it and/or modify |
||||
it under the terms of the GNU Affero General Public License as published by |
||||
the Free Software Foundation, either version 3 of the License, or |
||||
(at your option) any later version. |
||||
|
||||
This program is distributed in the hope that it will be useful, |
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
GNU Affero General Public License for more details. |
||||
|
||||
You should have received a copy of the GNU Affero General Public License |
||||
along with this program. If not, see <http://www.gnu.org/licenses/>. |
||||
|
||||
Also add information on how to contact you by electronic and paper mail. |
||||
|
||||
If your software can interact with users remotely through a computer |
||||
network, you should also make sure that it provides a way for users to |
||||
get its source. For example, if your program is a web application, its |
||||
interface could display a "Source" link that leads users to an archive |
||||
of the code. There are many ways you could offer source, and different |
||||
solutions will be better for different programs; see section 13 for the |
||||
specific requirements. |
||||
|
||||
You should also get your employer (if you work as a programmer) or school, |
||||
if any, to sign a "copyright disclaimer" for the program, if necessary. |
||||
For more information on this, and how to apply and follow the GNU AGPL, see |
||||
<http://www.gnu.org/licenses/>. |
||||
@ -0,0 +1,174 @@ |
||||
Apache License |
||||
Version 2.0, January 2004 |
||||
http://www.apache.org/licenses/ |
||||
|
||||
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION |
||||
|
||||
1. Definitions. |
||||
|
||||
"License" shall mean the terms and conditions for use, reproduction, |
||||
and distribution as defined by Sections 1 through 9 of this document. |
||||
|
||||
"Licensor" shall mean the copyright owner or entity authorized by |
||||
the copyright owner that is granting the License. |
||||
|
||||
"Legal Entity" shall mean the union of the acting entity and all |
||||
other entities that control, are controlled by, or are under common |
||||
control with that entity. For the purposes of this definition, |
||||
"control" means (i) the power, direct or indirect, to cause the |
||||
direction or management of such entity, whether by contract or |
||||
otherwise, or (ii) ownership of fifty percent (50%) or more of the |
||||
outstanding shares, or (iii) beneficial ownership of such entity. |
||||
|
||||
"You" (or "Your") shall mean an individual or Legal Entity |
||||
exercising permissions granted by this License. |
||||
|
||||
"Source" form shall mean the preferred form for making modifications, |
||||
including but not limited to software source code, documentation |
||||
source, and configuration files. |
||||
|
||||
"Object" form shall mean any form resulting from mechanical |
||||
transformation or translation of a Source form, including but |
||||
not limited to compiled object code, generated documentation, |
||||
and conversions to other media types. |
||||
|
||||
"Work" shall mean the work of authorship, whether in Source or |
||||
Object form, made available under the License, as indicated by a |
||||
copyright notice that is included in or attached to the work |
||||
(an example is provided in the Appendix below). |
||||
|
||||
"Derivative Works" shall mean any work, whether in Source or Object |
||||
form, that is based on (or derived from) the Work and for which the |
||||
editorial revisions, annotations, elaborations, or other modifications |
||||
represent, as a whole, an original work of authorship. For the purposes |
||||
of this License, Derivative Works shall not include works that remain |
||||
separable from, or merely link (or bind by name) to the interfaces of, |
||||
the Work and Derivative Works thereof. |
||||
|
||||
"Contribution" shall mean any work of authorship, including |
||||
the original version of the Work and any modifications or additions |
||||
to that Work or Derivative Works thereof, that is intentionally |
||||
submitted to Licensor for inclusion in the Work by the copyright owner |
||||
or by an individual or Legal Entity authorized to submit on behalf of |
||||
the copyright owner. For the purposes of this definition, "submitted" |
||||
means any form of electronic, verbal, or written communication sent |
||||
to the Licensor or its representatives, including but not limited to |
||||
communication on electronic mailing lists, source code control systems, |
||||
and issue tracking systems that are managed by, or on behalf of, the |
||||
Licensor for the purpose of discussing and improving the Work, but |
||||
excluding communication that is conspicuously marked or otherwise |
||||
designated in writing by the copyright owner as "Not a Contribution." |
||||
|
||||
"Contributor" shall mean Licensor and any individual or Legal Entity |
||||
on behalf of whom a Contribution has been received by Licensor and |
||||
subsequently incorporated within the Work. |
||||
|
||||
2. Grant of Copyright License. Subject to the terms and conditions of |
||||
this License, each Contributor hereby grants to You a perpetual, |
||||
worldwide, non-exclusive, no-charge, royalty-free, irrevocable |
||||
copyright license to reproduce, prepare Derivative Works of, |
||||
publicly display, publicly perform, sublicense, and distribute the |
||||
Work and such Derivative Works in Source or Object form. |
||||
|
||||
3. Grant of Patent License. Subject to the terms and conditions of |
||||
this License, each Contributor hereby grants to You a perpetual, |
||||
worldwide, non-exclusive, no-charge, royalty-free, irrevocable |
||||
(except as stated in this section) patent license to make, have made, |
||||
use, offer to sell, sell, import, and otherwise transfer the Work, |
||||
where such license applies only to those patent claims licensable |
||||
by such Contributor that are necessarily infringed by their |
||||
Contribution(s) alone or by combination of their Contribution(s) |
||||
with the Work to which such Contribution(s) was submitted. If You |
||||
institute patent litigation against any entity (including a |
||||
cross-claim or counterclaim in a lawsuit) alleging that the Work |
||||
or a Contribution incorporated within the Work constitutes direct |
||||
or contributory patent infringement, then any patent licenses |
||||
granted to You under this License for that Work shall terminate |
||||
as of the date such litigation is filed. |
||||
|
||||
4. Redistribution. You may reproduce and distribute copies of the |
||||
Work or Derivative Works thereof in any medium, with or without |
||||
modifications, and in Source or Object form, provided that You |
||||
meet the following conditions: |
||||
|
||||
(a) You must give any other recipients of the Work or |
||||
Derivative Works a copy of this License; and |
||||
|
||||
(b) You must cause any modified files to carry prominent notices |
||||
stating that You changed the files; and |
||||
|
||||
(c) You must retain, in the Source form of any Derivative Works |
||||
that You distribute, all copyright, patent, trademark, and |
||||
attribution notices from the Source form of the Work, |
||||
excluding those notices that do not pertain to any part of |
||||
the Derivative Works; and |
||||
|
||||
(d) If the Work includes a "NOTICE" text file as part of its |
||||
distribution, then any Derivative Works that You distribute must |
||||
include a readable copy of the attribution notices contained |
||||
within such NOTICE file, excluding those notices that do not |
||||
pertain to any part of the Derivative Works, in at least one |
||||
of the following places: within a NOTICE text file distributed |
||||
as part of the Derivative Works; within the Source form or |
||||
documentation, if provided along with the Derivative Works; or, |
||||
within a display generated by the Derivative Works, if and |
||||
wherever such third-party notices normally appear. The contents |
||||
of the NOTICE file are for informational purposes only and |
||||
do not modify the License. You may add Your own attribution |
||||
notices within Derivative Works that You distribute, alongside |
||||
or as an addendum to the NOTICE text from the Work, provided |
||||
that such additional attribution notices cannot be construed |
||||
as modifying the License. |
||||
|
||||
You may add Your own copyright statement to Your modifications and |
||||
may provide additional or different license terms and conditions |
||||
for use, reproduction, or distribution of Your modifications, or |
||||
for any such Derivative Works as a whole, provided Your use, |
||||
reproduction, and distribution of the Work otherwise complies with |
||||
the conditions stated in this License. |
||||
|
||||
5. Submission of Contributions. Unless You explicitly state otherwise, |
||||
any Contribution intentionally submitted for inclusion in the Work |
||||
by You to the Licensor shall be under the terms and conditions of |
||||
this License, without any additional terms or conditions. |
||||
Notwithstanding the above, nothing herein shall supersede or modify |
||||
the terms of any separate license agreement you may have executed |
||||
with Licensor regarding such Contributions. |
||||
|
||||
6. Trademarks. This License does not grant permission to use the trade |
||||
names, trademarks, service marks, or product names of the Licensor, |
||||
except as required for reasonable and customary use in describing the |
||||
origin of the Work and reproducing the content of the NOTICE file. |
||||
|
||||
7. Disclaimer of Warranty. Unless required by applicable law or |
||||
agreed to in writing, Licensor provides the Work (and each |
||||
Contributor provides its Contributions) on an "AS IS" BASIS, |
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or |
||||
implied, including, without limitation, any warranties or conditions |
||||
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A |
||||
PARTICULAR PURPOSE. You are solely responsible for determining the |
||||
appropriateness of using or redistributing the Work and assume any |
||||
risks associated with Your exercise of permissions under this License. |
||||
|
||||
8. Limitation of Liability. In no event and under no legal theory, |
||||
whether in tort (including negligence), contract, or otherwise, |
||||
unless required by applicable law (such as deliberate and grossly |
||||
negligent acts) or agreed to in writing, shall any Contributor be |
||||
liable to You for damages, including any direct, indirect, special, |
||||
incidental, or consequential damages of any character arising as a |
||||
result of this License or out of the use or inability to use the |
||||
Work (including but not limited to damages for loss of goodwill, |
||||
work stoppage, computer failure or malfunction, or any and all |
||||
other commercial damages or losses), even if such Contributor |
||||
has been advised of the possibility of such damages. |
||||
|
||||
9. Accepting Warranty or Additional Liability. While redistributing |
||||
the Work or Derivative Works thereof, You may choose to offer, |
||||
and charge a fee for, acceptance of support, warranty, indemnity, |
||||
or other liability obligations and/or rights consistent with this |
||||
License. However, in accepting such obligations, You may act only |
||||
on Your own behalf and on Your sole responsibility, not on behalf |
||||
of any other Contributor, and only if You agree to indemnify, |
||||
defend, and hold each Contributor harmless for any liability |
||||
incurred by, or claims asserted against, such Contributor by reason |
||||
of your accepting any such warranty or additional liability. |
||||
@ -0,0 +1,339 @@ |
||||
GNU GENERAL PUBLIC LICENSE |
||||
Version 2, June 1991 |
||||
|
||||
Copyright (C) 1989, 1991 Free Software Foundation, Inc., |
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
||||
Everyone is permitted to copy and distribute verbatim copies |
||||
of this license document, but changing it is not allowed. |
||||
|
||||
Preamble |
||||
|
||||
The licenses for most software are designed to take away your |
||||
freedom to share and change it. By contrast, the GNU General Public |
||||
License is intended to guarantee your freedom to share and change free |
||||
software--to make sure the software is free for all its users. This |
||||
General Public License applies to most of the Free Software |
||||
Foundation's software and to any other program whose authors commit to |
||||
using it. (Some other Free Software Foundation software is covered by |
||||
the GNU Lesser General Public License instead.) You can apply it to |
||||
your programs, too. |
||||
|
||||
When we speak of free software, we are referring to freedom, not |
||||
price. Our General Public Licenses are designed to make sure that you |
||||
have the freedom to distribute copies of free software (and charge for |
||||
this service if you wish), that you receive source code or can get it |
||||
if you want it, that you can change the software or use pieces of it |
||||
in new free programs; and that you know you can do these things. |
||||
|
||||
To protect your rights, we need to make restrictions that forbid |
||||
anyone to deny you these rights or to ask you to surrender the rights. |
||||
These restrictions translate to certain responsibilities for you if you |
||||
distribute copies of the software, or if you modify it. |
||||
|
||||
For example, if you distribute copies of such a program, whether |
||||
gratis or for a fee, you must give the recipients all the rights that |
||||
you have. You must make sure that they, too, receive or can get the |
||||
source code. And you must show them these terms so they know their |
||||
rights. |
||||
|
||||
We protect your rights with two steps: (1) copyright the software, and |
||||
(2) offer you this license which gives you legal permission to copy, |
||||
distribute and/or modify the software. |
||||
|
||||
Also, for each author's protection and ours, we want to make certain |
||||
that everyone understands that there is no warranty for this free |
||||
software. If the software is modified by someone else and passed on, we |
||||
want its recipients to know that what they have is not the original, so |
||||
that any problems introduced by others will not reflect on the original |
||||
authors' reputations. |
||||
|
||||
Finally, any free program is threatened constantly by software |
||||
patents. We wish to avoid the danger that redistributors of a free |
||||
program will individually obtain patent licenses, in effect making the |
||||
program proprietary. To prevent this, we have made it clear that any |
||||
patent must be licensed for everyone's free use or not licensed at all. |
||||
|
||||
The precise terms and conditions for copying, distribution and |
||||
modification follow. |
||||
|
||||
GNU GENERAL PUBLIC LICENSE |
||||
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION |
||||
|
||||
0. This License applies to any program or other work which contains |
||||
a notice placed by the copyright holder saying it may be distributed |
||||
under the terms of this General Public License. The "Program", below, |
||||
refers to any such program or work, and a "work based on the Program" |
||||
means either the Program or any derivative work under copyright law: |
||||
that is to say, a work containing the Program or a portion of it, |
||||
either verbatim or with modifications and/or translated into another |
||||
language. (Hereinafter, translation is included without limitation in |
||||
the term "modification".) Each licensee is addressed as "you". |
||||
|
||||
Activities other than copying, distribution and modification are not |
||||
covered by this License; they are outside its scope. The act of |
||||
running the Program is not restricted, and the output from the Program |
||||
is covered only if its contents constitute a work based on the |
||||
Program (independent of having been made by running the Program). |
||||
Whether that is true depends on what the Program does. |
||||
|
||||
1. You may copy and distribute verbatim copies of the Program's |
||||
source code as you receive it, in any medium, provided that you |
||||
conspicuously and appropriately publish on each copy an appropriate |
||||
copyright notice and disclaimer of warranty; keep intact all the |
||||
notices that refer to this License and to the absence of any warranty; |
||||
and give any other recipients of the Program a copy of this License |
||||
along with the Program. |
||||
|
||||
You may charge a fee for the physical act of transferring a copy, and |
||||
you may at your option offer warranty protection in exchange for a fee. |
||||
|
||||
2. You may modify your copy or copies of the Program or any portion |
||||
of it, thus forming a work based on the Program, and copy and |
||||
distribute such modifications or work under the terms of Section 1 |
||||
above, provided that you also meet all of these conditions: |
||||
|
||||
a) You must cause the modified files to carry prominent notices |
||||
stating that you changed the files and the date of any change. |
||||
|
||||
b) You must cause any work that you distribute or publish, that in |
||||
whole or in part contains or is derived from the Program or any |
||||
part thereof, to be licensed as a whole at no charge to all third |
||||
parties under the terms of this License. |
||||
|
||||
c) If the modified program normally reads commands interactively |
||||
when run, you must cause it, when started running for such |
||||
interactive use in the most ordinary way, to print or display an |
||||
announcement including an appropriate copyright notice and a |
||||
notice that there is no warranty (or else, saying that you provide |
||||
a warranty) and that users may redistribute the program under |
||||
these conditions, and telling the user how to view a copy of this |
||||
License. (Exception: if the Program itself is interactive but |
||||
does not normally print such an announcement, your work based on |
||||
the Program is not required to print an announcement.) |
||||
|
||||
These requirements apply to the modified work as a whole. If |
||||
identifiable sections of that work are not derived from the Program, |
||||
and can be reasonably considered independent and separate works in |
||||
themselves, then this License, and its terms, do not apply to those |
||||
sections when you distribute them as separate works. But when you |
||||
distribute the same sections as part of a whole which is a work based |
||||
on the Program, the distribution of the whole must be on the terms of |
||||
this License, whose permissions for other licensees extend to the |
||||
entire whole, and thus to each and every part regardless of who wrote it. |
||||
|
||||
Thus, it is not the intent of this section to claim rights or contest |
||||
your rights to work written entirely by you; rather, the intent is to |
||||
exercise the right to control the distribution of derivative or |
||||
collective works based on the Program. |
||||
|
||||
In addition, mere aggregation of another work not based on the Program |
||||
with the Program (or with a work based on the Program) on a volume of |
||||
a storage or distribution medium does not bring the other work under |
||||
the scope of this License. |
||||
|
||||
3. You may copy and distribute the Program (or a work based on it, |
||||
under Section 2) in object code or executable form under the terms of |
||||
Sections 1 and 2 above provided that you also do one of the following: |
||||
|
||||
a) Accompany it with the complete corresponding machine-readable |
||||
source code, which must be distributed under the terms of Sections |
||||
1 and 2 above on a medium customarily used for software interchange; or, |
||||
|
||||
b) Accompany it with a written offer, valid for at least three |
||||
years, to give any third party, for a charge no more than your |
||||
cost of physically performing source distribution, a complete |
||||
machine-readable copy of the corresponding source code, to be |
||||
distributed under the terms of Sections 1 and 2 above on a medium |
||||
customarily used for software interchange; or, |
||||
|
||||
c) Accompany it with the information you received as to the offer |
||||
to distribute corresponding source code. (This alternative is |
||||
allowed only for noncommercial distribution and only if you |
||||
received the program in object code or executable form with such |
||||
an offer, in accord with Subsection b above.) |
||||
|
||||
The source code for a work means the preferred form of the work for |
||||
making modifications to it. For an executable work, complete source |
||||
code means all the source code for all modules it contains, plus any |
||||
associated interface definition files, plus the scripts used to |
||||
control compilation and installation of the executable. However, as a |
||||
special exception, the source code distributed need not include |
||||
anything that is normally distributed (in either source or binary |
||||
form) with the major components (compiler, kernel, and so on) of the |
||||
operating system on which the executable runs, unless that component |
||||
itself accompanies the executable. |
||||
|
||||
If distribution of executable or object code is made by offering |
||||
access to copy from a designated place, then offering equivalent |
||||
access to copy the source code from the same place counts as |
||||
distribution of the source code, even though third parties are not |
||||
compelled to copy the source along with the object code. |
||||
|
||||
4. You may not copy, modify, sublicense, or distribute the Program |
||||
except as expressly provided under this License. Any attempt |
||||
otherwise to copy, modify, sublicense or distribute the Program is |
||||
void, and will automatically terminate your rights under this License. |
||||
However, parties who have received copies, or rights, from you under |
||||
this License will not have their licenses terminated so long as such |
||||
parties remain in full compliance. |
||||
|
||||
5. You are not required to accept this License, since you have not |
||||
signed it. However, nothing else grants you permission to modify or |
||||
distribute the Program or its derivative works. These actions are |
||||
prohibited by law if you do not accept this License. Therefore, by |
||||
modifying or distributing the Program (or any work based on the |
||||
Program), you indicate your acceptance of this License to do so, and |
||||
all its terms and conditions for copying, distributing or modifying |
||||
the Program or works based on it. |
||||
|
||||
6. Each time you redistribute the Program (or any work based on the |
||||
Program), the recipient automatically receives a license from the |
||||
original licensor to copy, distribute or modify the Program subject to |
||||
these terms and conditions. You may not impose any further |
||||
restrictions on the recipients' exercise of the rights granted herein. |
||||
You are not responsible for enforcing compliance by third parties to |
||||
this License. |
||||
|
||||
7. If, as a consequence of a court judgment or allegation of patent |
||||
infringement or for any other reason (not limited to patent issues), |
||||
conditions are imposed on you (whether by court order, agreement or |
||||
otherwise) that contradict the conditions of this License, they do not |
||||
excuse you from the conditions of this License. If you cannot |
||||
distribute so as to satisfy simultaneously your obligations under this |
||||
License and any other pertinent obligations, then as a consequence you |
||||
may not distribute the Program at all. For example, if a patent |
||||
license would not permit royalty-free redistribution of the Program by |
||||
all those who receive copies directly or indirectly through you, then |
||||
the only way you could satisfy both it and this License would be to |
||||
refrain entirely from distribution of the Program. |
||||
|
||||
If any portion of this section is held invalid or unenforceable under |
||||
any particular circumstance, the balance of the section is intended to |
||||
apply and the section as a whole is intended to apply in other |
||||
circumstances. |
||||
|
||||
It is not the purpose of this section to induce you to infringe any |
||||
patents or other property right claims or to contest validity of any |
||||
such claims; this section has the sole purpose of protecting the |
||||
integrity of the free software distribution system, which is |
||||
implemented by public license practices. Many people have made |
||||
generous contributions to the wide range of software distributed |
||||
through that system in reliance on consistent application of that |
||||
system; it is up to the author/donor to decide if he or she is willing |
||||
to distribute software through any other system and a licensee cannot |
||||
impose that choice. |
||||
|
||||
This section is intended to make thoroughly clear what is believed to |
||||
be a consequence of the rest of this License. |
||||
|
||||
8. If the distribution and/or use of the Program is restricted in |
||||
certain countries either by patents or by copyrighted interfaces, the |
||||
original copyright holder who places the Program under this License |
||||
may add an explicit geographical distribution limitation excluding |
||||
those countries, so that distribution is permitted only in or among |
||||
countries not thus excluded. In such case, this License incorporates |
||||
the limitation as if written in the body of this License. |
||||
|
||||
9. The Free Software Foundation may publish revised and/or new versions |
||||
of the General Public License from time to time. Such new versions will |
||||
be similar in spirit to the present version, but may differ in detail to |
||||
address new problems or concerns. |
||||
|
||||
Each version is given a distinguishing version number. If the Program |
||||
specifies a version number of this License which applies to it and "any |
||||
later version", you have the option of following the terms and conditions |
||||
either of that version or of any later version published by the Free |
||||
Software Foundation. If the Program does not specify a version number of |
||||
this License, you may choose any version ever published by the Free Software |
||||
Foundation. |
||||
|
||||
10. If you wish to incorporate parts of the Program into other free |
||||
programs whose distribution conditions are different, write to the author |
||||
to ask for permission. For software which is copyrighted by the Free |
||||
Software Foundation, write to the Free Software Foundation; we sometimes |
||||
make exceptions for this. Our decision will be guided by the two goals |
||||
of preserving the free status of all derivatives of our free software and |
||||
of promoting the sharing and reuse of software generally. |
||||
|
||||
NO WARRANTY |
||||
|
||||
11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY |
||||
FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN |
||||
OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES |
||||
PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED |
||||
OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
||||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS |
||||
TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE |
||||
PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, |
||||
REPAIR OR CORRECTION. |
||||
|
||||
12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING |
||||
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR |
||||
REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, |
||||
INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING |
||||
OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED |
||||
TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY |
||||
YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER |
||||
PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE |
||||
POSSIBILITY OF SUCH DAMAGES. |
||||
|
||||
END OF TERMS AND CONDITIONS |
||||
|
||||
How to Apply These Terms to Your New Programs |
||||
|
||||
If you develop a new program, and you want it to be of the greatest |
||||
possible use to the public, the best way to achieve this is to make it |
||||
free software which everyone can redistribute and change under these terms. |
||||
|
||||
To do so, attach the following notices to the program. It is safest |
||||
to attach them to the start of each source file to most effectively |
||||
convey the exclusion of warranty; and each file should have at least |
||||
the "copyright" line and a pointer to where the full notice is found. |
||||
|
||||
<one line to give the program's name and a brief idea of what it does.> |
||||
Copyright (C) <year> <name of author> |
||||
|
||||
This program is free software; you can redistribute it and/or modify |
||||
it under the terms of the GNU General Public License as published by |
||||
the Free Software Foundation; either version 2 of the License, or |
||||
(at your option) any later version. |
||||
|
||||
This program is distributed in the hope that it will be useful, |
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
GNU General Public License for more details. |
||||
|
||||
You should have received a copy of the GNU General Public License along |
||||
with this program; if not, write to the Free Software Foundation, Inc., |
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. |
||||
|
||||
Also add information on how to contact you by electronic and paper mail. |
||||
|
||||
If the program is interactive, make it output a short notice like this |
||||
when it starts in an interactive mode: |
||||
|
||||
Gnomovision version 69, Copyright (C) year name of author |
||||
Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. |
||||
This is free software, and you are welcome to redistribute it |
||||
under certain conditions; type `show c' for details. |
||||
|
||||
The hypothetical commands `show w' and `show c' should show the appropriate |
||||
parts of the General Public License. Of course, the commands you use may |
||||
be called something other than `show w' and `show c'; they could even be |
||||
mouse-clicks or menu items--whatever suits your program. |
||||
|
||||
You should also get your employer (if you work as a programmer) or your |
||||
school, if any, to sign a "copyright disclaimer" for the program, if |
||||
necessary. Here is a sample; alter the names: |
||||
|
||||
Yoyodyne, Inc., hereby disclaims all copyright interest in the program |
||||
`Gnomovision' (which makes passes at compilers) written by James Hacker. |
||||
|
||||
<signature of Ty Coon>, 1 April 1989 |
||||
Ty Coon, President of Vice |
||||
|
||||
This General Public License does not permit incorporating your program into |
||||
proprietary programs. If your program is a subroutine library, you may |
||||
consider it more useful to permit linking proprietary applications with the |
||||
library. If this is what you want to do, use the GNU Lesser General |
||||
Public License instead of this License. |
||||
@ -0,0 +1,13 @@ |
||||
The files in this directory originally come from |
||||
https://github.com/percona/PerconaFT/. |
||||
|
||||
This directory only includes the "locktree" part of PerconaFT, and its |
||||
dependencies. |
||||
|
||||
The following modifications were made: |
||||
- Make locktree usable outside of PerconaFT library |
||||
- Add shared read-only lock support |
||||
|
||||
The files named *_subst.* are substitutes of the PerconaFT's files, they |
||||
contain replacements of PerconaFT's functionality. |
||||
|
||||
@ -0,0 +1,76 @@ |
||||
#ifndef _DB_H |
||||
#define _DB_H |
||||
|
||||
#include <stdint.h> |
||||
#include <sys/types.h> |
||||
|
||||
typedef struct __toku_dbt DBT; |
||||
|
||||
// port: this is currently not used
|
||||
struct simple_dbt { |
||||
uint32_t len; |
||||
void *data; |
||||
}; |
||||
|
||||
// engine status info
|
||||
// engine status is passed to handlerton as an array of
|
||||
// TOKU_ENGINE_STATUS_ROW_S[]
|
||||
typedef enum { |
||||
STATUS_FS_STATE = 0, // interpret as file system state (redzone) enum
|
||||
STATUS_UINT64, // interpret as uint64_t
|
||||
STATUS_CHARSTR, // interpret as char *
|
||||
STATUS_UNIXTIME, // interpret as time_t
|
||||
STATUS_TOKUTIME, // interpret as tokutime_t
|
||||
STATUS_PARCOUNT, // interpret as PARTITIONED_COUNTER
|
||||
STATUS_DOUBLE // interpret as double
|
||||
} toku_engine_status_display_type; |
||||
|
||||
typedef enum { |
||||
TOKU_ENGINE_STATUS = (1ULL << 0), // Include when asking for engine status
|
||||
TOKU_GLOBAL_STATUS = |
||||
(1ULL << 1), // Include when asking for information_schema.global_status
|
||||
} toku_engine_status_include_type; |
||||
|
||||
typedef struct __toku_engine_status_row { |
||||
const char *keyname; // info schema key, should not change across revisions
|
||||
// without good reason
|
||||
const char |
||||
*columnname; // column for mysql, e.g. information_schema.global_status.
|
||||
// TOKUDB_ will automatically be prefixed.
|
||||
const char *legend; // the text that will appear at user interface
|
||||
toku_engine_status_display_type type; // how to interpret the value
|
||||
toku_engine_status_include_type |
||||
include; // which kinds of callers should get read this row?
|
||||
union { |
||||
double dnum; |
||||
uint64_t num; |
||||
const char *str; |
||||
char datebuf[26]; |
||||
struct partitioned_counter *parcount; |
||||
} value; |
||||
} * TOKU_ENGINE_STATUS_ROW, TOKU_ENGINE_STATUS_ROW_S; |
||||
|
||||
#define DB_BUFFER_SMALL -30999 |
||||
#define DB_LOCK_DEADLOCK -30995 |
||||
#define DB_LOCK_NOTGRANTED -30994 |
||||
#define DB_NOTFOUND -30989 |
||||
#define DB_KEYEXIST -30996 |
||||
#define DB_DBT_MALLOC 8 |
||||
#define DB_DBT_REALLOC 64 |
||||
#define DB_DBT_USERMEM 256 |
||||
|
||||
/* PerconaFT specific error codes */ |
||||
#define TOKUDB_OUT_OF_LOCKS -100000 |
||||
|
||||
typedef void (*lock_wait_callback)(void *arg, uint64_t requesting_txnid, |
||||
uint64_t blocking_txnid); |
||||
|
||||
struct __toku_dbt { |
||||
void *data; |
||||
size_t size; |
||||
size_t ulen; |
||||
// One of DB_DBT_XXX flags
|
||||
uint32_t flags; |
||||
}; |
||||
|
||||
#endif |
||||
@ -0,0 +1,124 @@ |
||||
/* -*- mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */ |
||||
// vim: ft=cpp:expandtab:ts=8:sw=4:softtabstop=4:
|
||||
/*======
|
||||
This file is part of PerconaFT. |
||||
|
||||
|
||||
Copyright (c) 2006, 2015, Percona and/or its affiliates. All rights reserved. |
||||
|
||||
PerconaFT is free software: you can redistribute it and/or modify |
||||
it under the terms of the GNU General Public License, version 2, |
||||
as published by the Free Software Foundation. |
||||
|
||||
PerconaFT is distributed in the hope that it will be useful, |
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
GNU General Public License for more details. |
||||
|
||||
You should have received a copy of the GNU General Public License |
||||
along with PerconaFT. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
---------------------------------------- |
||||
|
||||
PerconaFT is free software: you can redistribute it and/or modify |
||||
it under the terms of the GNU Affero General Public License, version 3, |
||||
as published by the Free Software Foundation. |
||||
|
||||
PerconaFT is distributed in the hope that it will be useful, |
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
GNU Affero General Public License for more details. |
||||
|
||||
You should have received a copy of the GNU Affero General Public License |
||||
along with PerconaFT. If not, see <http://www.gnu.org/licenses/>.
|
||||
======= */ |
||||
|
||||
#ident \ |
||||
"Copyright (c) 2006, 2015, Percona and/or its affiliates. All rights reserved." |
||||
|
||||
#pragma once |
||||
|
||||
#include <string.h> |
||||
|
||||
#include "../db.h" |
||||
#include "../portability/memory.h" |
||||
#include "../util/dbt.h" |
||||
|
||||
typedef int (*ft_compare_func)(void *arg, const DBT *a, const DBT *b); |
||||
|
||||
int toku_keycompare(const void *key1, size_t key1len, const void *key2, |
||||
size_t key2len); |
||||
|
||||
int toku_builtin_compare_fun(const DBT *, const DBT *) |
||||
__attribute__((__visibility__("default"))); |
||||
|
||||
namespace toku { |
||||
|
||||
// a comparator object encapsulates the data necessary for
|
||||
// comparing two keys in a fractal tree. it further understands
|
||||
// that points may be positive or negative infinity.
|
||||
|
||||
class comparator { |
||||
void init(ft_compare_func cmp, void *cmp_arg, uint8_t memcmp_magic) { |
||||
_cmp = cmp; |
||||
_cmp_arg = cmp_arg; |
||||
_memcmp_magic = memcmp_magic; |
||||
} |
||||
|
||||
public: |
||||
// This magic value is reserved to mean that the magic has not been set.
|
||||
static const uint8_t MEMCMP_MAGIC_NONE = 0; |
||||
|
||||
void create(ft_compare_func cmp, void *cmp_arg, |
||||
uint8_t memcmp_magic = MEMCMP_MAGIC_NONE) { |
||||
init(cmp, cmp_arg, memcmp_magic); |
||||
} |
||||
|
||||
// inherit the attributes of another comparator, but keep our own
|
||||
// copy of fake_db that is owned separately from the one given.
|
||||
void inherit(const comparator &cmp) { |
||||
invariant_notnull(cmp._cmp); |
||||
init(cmp._cmp, cmp._cmp_arg, cmp._memcmp_magic); |
||||
} |
||||
|
||||
// like inherit, but doesn't require that the this comparator
|
||||
// was already created
|
||||
void create_from(const comparator &cmp) { inherit(cmp); } |
||||
|
||||
void destroy() {} |
||||
|
||||
ft_compare_func get_compare_func() const { return _cmp; } |
||||
|
||||
uint8_t get_memcmp_magic() const { return _memcmp_magic; } |
||||
|
||||
bool valid() const { return _cmp != nullptr; } |
||||
|
||||
inline bool dbt_has_memcmp_magic(const DBT *dbt) const { |
||||
return *reinterpret_cast<const char *>(dbt->data) == _memcmp_magic; |
||||
} |
||||
|
||||
int operator()(const DBT *a, const DBT *b) const { |
||||
if (__builtin_expect(toku_dbt_is_infinite(a) || toku_dbt_is_infinite(b), |
||||
0)) { |
||||
return toku_dbt_infinite_compare(a, b); |
||||
} else if (_memcmp_magic != MEMCMP_MAGIC_NONE |
||||
// If `a' has the memcmp magic..
|
||||
&& dbt_has_memcmp_magic(a) |
||||
// ..then we expect `b' to also have the memcmp magic
|
||||
&& __builtin_expect(dbt_has_memcmp_magic(b), 1)) { |
||||
assert(0); // psergey: this branch should not be taken.
|
||||
return toku_builtin_compare_fun(a, b); |
||||
} else { |
||||
// yikes, const sadness here
|
||||
return _cmp(_cmp_arg, a, b); |
||||
} |
||||
} |
||||
|
||||
private: |
||||
ft_compare_func _cmp; |
||||
void *_cmp_arg; |
||||
|
||||
uint8_t _memcmp_magic; |
||||
}; |
||||
|
||||
} /* namespace toku */ |
||||
@ -0,0 +1,88 @@ |
||||
/* -*- mode: C++; c-basic-offset: 4; indent-tabs-mode: nil -*- */ |
||||
// vim: ft=cpp:expandtab:ts=8:sw=4:softtabstop=4:
|
||||
#ident "$Id$" |
||||
/*======
|
||||
This file is part of PerconaFT. |
||||
|
||||
|
||||
Copyright (c) 2006, 2015, Percona and/or its affiliates. All rights reserved. |
||||
|
||||
PerconaFT is free software: you can redistribute it and/or modify |
||||
it under the terms of the GNU General Public License, version 2, |
||||
as published by the Free Software Foundation. |
||||
|
||||
PerconaFT is distributed in the hope that it will be useful, |
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
GNU General Public License for more details. |
||||
|
||||
You should have received a copy of the GNU General Public License |
||||
along with PerconaFT. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
---------------------------------------- |
||||
|
||||
PerconaFT is free software: you can redistribute it and/or modify |
||||
it under the terms of the GNU Affero General Public License, version 3, |
||||
as published by the Free Software Foundation. |
||||
|
||||
PerconaFT is distributed in the hope that it will be useful, |
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
GNU Affero General Public License for more details. |
||||
|
||||
You should have received a copy of the GNU Affero General Public License |
||||
along with PerconaFT. If not, see <http://www.gnu.org/licenses/>.
|
||||
======= */ |
||||
|
||||
#ident \ |
||||
"Copyright (c) 2006, 2015, Percona and/or its affiliates. All rights reserved." |
||||
|
||||
#pragma once |
||||
|
||||
#include "../db.h" |
||||
#include "../portability/toku_race_tools.h" |
||||
#include "../util/status.h" |
||||
|
||||
//
|
||||
// Lock Tree Manager statistics
|
||||
//
|
||||
class LTM_STATUS_S { |
||||
public: |
||||
enum { |
||||
LTM_SIZE_CURRENT = 0, |
||||
LTM_SIZE_LIMIT, |
||||
LTM_ESCALATION_COUNT, |
||||
LTM_ESCALATION_TIME, |
||||
LTM_ESCALATION_LATEST_RESULT, |
||||
LTM_NUM_LOCKTREES, |
||||
LTM_LOCK_REQUESTS_PENDING, |
||||
LTM_STO_NUM_ELIGIBLE, |
||||
LTM_STO_END_EARLY_COUNT, |
||||
LTM_STO_END_EARLY_TIME, |
||||
LTM_WAIT_COUNT, |
||||
LTM_WAIT_TIME, |
||||
LTM_LONG_WAIT_COUNT, |
||||
LTM_LONG_WAIT_TIME, |
||||
LTM_TIMEOUT_COUNT, |
||||
LTM_WAIT_ESCALATION_COUNT, |
||||
LTM_WAIT_ESCALATION_TIME, |
||||
LTM_LONG_WAIT_ESCALATION_COUNT, |
||||
LTM_LONG_WAIT_ESCALATION_TIME, |
||||
LTM_STATUS_NUM_ROWS // must be last
|
||||
}; |
||||
|
||||
void init(void); |
||||
void destroy(void); |
||||
|
||||
TOKU_ENGINE_STATUS_ROW_S status[LTM_STATUS_NUM_ROWS]; |
||||
|
||||
private: |
||||
bool m_initialized = false; |
||||
}; |
||||
typedef LTM_STATUS_S* LTM_STATUS; |
||||
extern LTM_STATUS_S ltm_status; |
||||
|
||||
#define LTM_STATUS_VAL(x) ltm_status.status[LTM_STATUS_S::x].value.num |
||||
|
||||
void toku_status_init(void); // just call ltm_status.init();
|
||||
void toku_status_destroy(void); // just call ltm_status.destroy();
|
||||
@ -0,0 +1,139 @@ |
||||
/* -*- mode: C++; c-basic-offset: 4; indent-tabs-mode: nil -*- */ |
||||
// vim: ft=cpp:expandtab:ts=8:sw=4:softtabstop=4:
|
||||
#ifndef ROCKSDB_LITE |
||||
#ifndef OS_WIN |
||||
#ident "$Id$" |
||||
/*======
|
||||
This file is part of PerconaFT. |
||||
|
||||
|
||||
Copyright (c) 2006, 2015, Percona and/or its affiliates. All rights reserved. |
||||
|
||||
PerconaFT is free software: you can redistribute it and/or modify |
||||
it under the terms of the GNU General Public License, version 2, |
||||
as published by the Free Software Foundation. |
||||
|
||||
PerconaFT is distributed in the hope that it will be useful, |
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
GNU General Public License for more details. |
||||
|
||||
You should have received a copy of the GNU General Public License |
||||
along with PerconaFT. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
---------------------------------------- |
||||
|
||||
PerconaFT is free software: you can redistribute it and/or modify |
||||
it under the terms of the GNU Affero General Public License, version 3, |
||||
as published by the Free Software Foundation. |
||||
|
||||
PerconaFT is distributed in the hope that it will be useful, |
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
GNU Affero General Public License for more details. |
||||
|
||||
You should have received a copy of the GNU Affero General Public License |
||||
along with PerconaFT. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
---------------------------------------- |
||||
|
||||
Licensed under the Apache License, Version 2.0 (the "License"); |
||||
you may not use this file except in compliance with the License. |
||||
You may obtain a copy of the License at |
||||
|
||||
http://www.apache.org/licenses/LICENSE-2.0
|
||||
|
||||
Unless required by applicable law or agreed to in writing, software |
||||
distributed under the License is distributed on an "AS IS" BASIS, |
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
||||
See the License for the specific language governing permissions and |
||||
limitations under the License. |
||||
======= */ |
||||
|
||||
#ident \ |
||||
"Copyright (c) 2006, 2015, Percona and/or its affiliates. All rights reserved." |
||||
|
||||
#include "concurrent_tree.h" |
||||
|
||||
// PORT #include <toku_assert.h>
|
||||
namespace toku { |
||||
|
||||
void concurrent_tree::create(const comparator *cmp) { |
||||
// start with an empty root node. we do this instead of
|
||||
// setting m_root to null so there's always a root to lock
|
||||
m_root.create_root(cmp); |
||||
} |
||||
|
||||
void concurrent_tree::destroy(void) { m_root.destroy_root(); } |
||||
|
||||
bool concurrent_tree::is_empty(void) { return m_root.is_empty(); } |
||||
|
||||
uint64_t concurrent_tree::get_insertion_memory_overhead(void) { |
||||
return sizeof(treenode); |
||||
} |
||||
|
||||
void concurrent_tree::locked_keyrange::prepare(concurrent_tree *tree) { |
||||
// the first step in acquiring a locked keyrange is locking the root
|
||||
treenode *const root = &tree->m_root; |
||||
m_tree = tree; |
||||
m_subtree = root; |
||||
m_range = keyrange::get_infinite_range(); |
||||
root->mutex_lock(); |
||||
} |
||||
|
||||
void concurrent_tree::locked_keyrange::acquire(const keyrange &range) { |
||||
treenode *const root = &m_tree->m_root; |
||||
|
||||
treenode *subtree; |
||||
if (root->is_empty() || root->range_overlaps(range)) { |
||||
subtree = root; |
||||
} else { |
||||
// we do not have a precomputed comparison hint, so pass null
|
||||
const keyrange::comparison *cmp_hint = nullptr; |
||||
subtree = root->find_node_with_overlapping_child(range, cmp_hint); |
||||
} |
||||
|
||||
// subtree is locked. it will be unlocked when this is release()'d
|
||||
invariant_notnull(subtree); |
||||
m_range = range; |
||||
m_subtree = subtree; |
||||
} |
||||
|
||||
bool concurrent_tree::locked_keyrange::add_shared_owner(const keyrange &range, |
||||
TXNID new_owner) { |
||||
return m_subtree->insert(range, new_owner, /*is_shared*/ true); |
||||
} |
||||
|
||||
void concurrent_tree::locked_keyrange::release(void) { |
||||
m_subtree->mutex_unlock(); |
||||
} |
||||
|
||||
void concurrent_tree::locked_keyrange::insert(const keyrange &range, |
||||
TXNID txnid, bool is_shared) { |
||||
// empty means no children, and only the root should ever be empty
|
||||
if (m_subtree->is_empty()) { |
||||
m_subtree->set_range_and_txnid(range, txnid, is_shared); |
||||
} else { |
||||
m_subtree->insert(range, txnid, is_shared); |
||||
} |
||||
} |
||||
|
||||
void concurrent_tree::locked_keyrange::remove(const keyrange &range, |
||||
TXNID txnid) { |
||||
invariant(!m_subtree->is_empty()); |
||||
treenode *new_subtree = m_subtree->remove(range, txnid); |
||||
// if removing range changed the root of the subtree,
|
||||
// then the subtree must be the root of the entire tree.
|
||||
if (new_subtree == nullptr) { |
||||
invariant(m_subtree->is_root()); |
||||
invariant(m_subtree->is_empty()); |
||||
} |
||||
} |
||||
|
||||
void concurrent_tree::locked_keyrange::remove_all(void) { |
||||
m_subtree->recursive_remove(); |
||||
} |
||||
|
||||
} /* namespace toku */ |
||||
#endif // OS_WIN
|
||||
#endif // ROCKSDB_LITE
|
||||
@ -0,0 +1,174 @@ |
||||
/* -*- mode: C++; c-basic-offset: 4; indent-tabs-mode: nil -*- */ |
||||
// vim: ft=cpp:expandtab:ts=8:sw=2:softtabstop=2:
|
||||
#ident "$Id$" |
||||
/*======
|
||||
This file is part of PerconaFT. |
||||
|
||||
|
||||
Copyright (c) 2006, 2015, Percona and/or its affiliates. All rights reserved. |
||||
|
||||
PerconaFT is free software: you can redistribute it and/or modify |
||||
it under the terms of the GNU General Public License, version 2, |
||||
as published by the Free Software Foundation. |
||||
|
||||
PerconaFT is distributed in the hope that it will be useful, |
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
GNU General Public License for more details. |
||||
|
||||
You should have received a copy of the GNU General Public License |
||||
along with PerconaFT. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
---------------------------------------- |
||||
|
||||
PerconaFT is free software: you can redistribute it and/or modify |
||||
it under the terms of the GNU Affero General Public License, version 3, |
||||
as published by the Free Software Foundation. |
||||
|
||||
PerconaFT is distributed in the hope that it will be useful, |
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
GNU Affero General Public License for more details. |
||||
|
||||
You should have received a copy of the GNU Affero General Public License |
||||
along with PerconaFT. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
---------------------------------------- |
||||
|
||||
Licensed under the Apache License, Version 2.0 (the "License"); |
||||
you may not use this file except in compliance with the License. |
||||
You may obtain a copy of the License at |
||||
|
||||
http://www.apache.org/licenses/LICENSE-2.0
|
||||
|
||||
Unless required by applicable law or agreed to in writing, software |
||||
distributed under the License is distributed on an "AS IS" BASIS, |
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
||||
See the License for the specific language governing permissions and |
||||
limitations under the License. |
||||
======= */ |
||||
|
||||
#ident \ |
||||
"Copyright (c) 2006, 2015, Percona and/or its affiliates. All rights reserved." |
||||
|
||||
#pragma once |
||||
|
||||
#include "../ft/comparator.h" |
||||
#include "keyrange.h" |
||||
#include "treenode.h" |
||||
|
||||
namespace toku { |
||||
|
||||
// A concurrent_tree stores non-overlapping ranges.
|
||||
// Access to disjoint parts of the tree usually occurs concurrently.
|
||||
|
||||
class concurrent_tree { |
||||
public: |
||||
// A locked_keyrange gives you exclusive access to read and write
|
||||
// operations that occur on any keys in that range. You only have
|
||||
// the right to operate on keys in that range or keys that were read
|
||||
// from the keyrange using iterate()
|
||||
//
|
||||
// Access model:
|
||||
// - user prepares a locked keyrange. all threads serialize behind prepare().
|
||||
// - user breaks the serialzation point by acquiring a range, or releasing.
|
||||
// - one thread operates on a certain locked_keyrange object at a time.
|
||||
// - when the thread is finished, it releases
|
||||
|
||||
class locked_keyrange { |
||||
public: |
||||
// effect: prepare to acquire a locked keyrange over the given
|
||||
// concurrent_tree, preventing other threads from preparing
|
||||
// until this thread either does acquire() or release().
|
||||
// note: operations performed on a prepared keyrange are equivalent
|
||||
// to ones performed on an acquired keyrange over -inf, +inf.
|
||||
// rationale: this provides the user with a serialization point for
|
||||
// descending
|
||||
// or modifying the the tree. it also proives a convenient way of
|
||||
// doing serializable operations on the tree.
|
||||
// There are two valid sequences of calls:
|
||||
// - prepare, acquire, [operations], release
|
||||
// - prepare, [operations],release
|
||||
void prepare(concurrent_tree *tree); |
||||
|
||||
// requires: the locked keyrange was prepare()'d
|
||||
// effect: acquire a locked keyrange over the given concurrent_tree.
|
||||
// the locked keyrange represents the range of keys overlapped
|
||||
// by the given range
|
||||
void acquire(const keyrange &range); |
||||
|
||||
// effect: releases a locked keyrange and the mutex it holds
|
||||
void release(void); |
||||
|
||||
// effect: iterate over each range this locked_keyrange represents,
|
||||
// calling function->fn() on each node's keyrange and txnid
|
||||
// until there are no more or the function returns false
|
||||
template <class F> |
||||
void iterate(F *function) const { |
||||
// if the subtree is non-empty, traverse it by calling the given
|
||||
// function on each range, txnid pair found that overlaps.
|
||||
if (!m_subtree->is_empty()) { |
||||
m_subtree->traverse_overlaps(m_range, function); |
||||
} |
||||
} |
||||
|
||||
// Adds another owner to the lock on the specified keyrange.
|
||||
// requires: the keyrange contains one treenode whose bounds are
|
||||
// exactly equal to the specifed range (no sub/supersets)
|
||||
bool add_shared_owner(const keyrange &range, TXNID new_owner); |
||||
|
||||
// inserts the given range into the tree, with an associated txnid.
|
||||
// requires: range does not overlap with anything in this locked_keyrange
|
||||
// rationale: caller is responsible for only inserting unique ranges
|
||||
void insert(const keyrange &range, TXNID txnid, bool is_shared); |
||||
|
||||
// effect: removes the given range from the tree.
|
||||
// - txnid=TXNID_ANY means remove the range no matter what its
|
||||
// owners are
|
||||
// - Other value means remove the specified txnid from
|
||||
// ownership (if the range has other owners, it will remain
|
||||
// in the tree)
|
||||
// requires: range exists exactly in this locked_keyrange
|
||||
// rationale: caller is responsible for only removing existing ranges
|
||||
void remove(const keyrange &range, TXNID txnid); |
||||
|
||||
// effect: removes all of the keys represented by this locked keyrange
|
||||
// rationale: we'd like a fast way to empty out a tree
|
||||
void remove_all(void); |
||||
|
||||
private: |
||||
// the concurrent tree this locked keyrange is for
|
||||
concurrent_tree *m_tree; |
||||
|
||||
// the range of keys this locked keyrange represents
|
||||
keyrange m_range; |
||||
|
||||
// the subtree under which all overlapping ranges exist
|
||||
treenode *m_subtree; |
||||
|
||||
friend class concurrent_tree_unit_test; |
||||
}; |
||||
|
||||
// effect: initialize the tree to an empty state
|
||||
void create(const comparator *cmp); |
||||
|
||||
// effect: destroy the tree.
|
||||
// requires: tree is empty
|
||||
void destroy(void); |
||||
|
||||
// returns: true iff the tree is empty
|
||||
bool is_empty(void); |
||||
|
||||
// returns: the memory overhead of a single insertion into the tree
|
||||
static uint64_t get_insertion_memory_overhead(void); |
||||
|
||||
private: |
||||
// the root needs to always exist so there's a lock to grab
|
||||
// even if the tree is empty. that's why we store a treenode
|
||||
// here and not a pointer to one.
|
||||
treenode m_root; |
||||
|
||||
friend class concurrent_tree_unit_test; |
||||
}; |
||||
|
||||
} /* namespace toku */ |
||||
@ -0,0 +1,221 @@ |
||||
/* -*- mode: C++; c-basic-offset: 4; indent-tabs-mode: nil -*- */ |
||||
// vim: ft=cpp:expandtab:ts=8:sw=4:softtabstop=4:
|
||||
#ifndef ROCKSDB_LITE |
||||
#ifndef OS_WIN |
||||
#ident "$Id$" |
||||
/*======
|
||||
This file is part of PerconaFT. |
||||
|
||||
|
||||
Copyright (c) 2006, 2015, Percona and/or its affiliates. All rights reserved. |
||||
|
||||
PerconaFT is free software: you can redistribute it and/or modify |
||||
it under the terms of the GNU General Public License, version 2, |
||||
as published by the Free Software Foundation. |
||||
|
||||
PerconaFT is distributed in the hope that it will be useful, |
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
GNU General Public License for more details. |
||||
|
||||
You should have received a copy of the GNU General Public License |
||||
along with PerconaFT. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
---------------------------------------- |
||||
|
||||
PerconaFT is free software: you can redistribute it and/or modify |
||||
it under the terms of the GNU Affero General Public License, version 3, |
||||
as published by the Free Software Foundation. |
||||
|
||||
PerconaFT is distributed in the hope that it will be useful, |
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
GNU Affero General Public License for more details. |
||||
|
||||
You should have received a copy of the GNU Affero General Public License |
||||
along with PerconaFT. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
---------------------------------------- |
||||
|
||||
Licensed under the Apache License, Version 2.0 (the "License"); |
||||
you may not use this file except in compliance with the License. |
||||
You may obtain a copy of the License at |
||||
|
||||
http://www.apache.org/licenses/LICENSE-2.0
|
||||
|
||||
Unless required by applicable law or agreed to in writing, software |
||||
distributed under the License is distributed on an "AS IS" BASIS, |
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
||||
See the License for the specific language governing permissions and |
||||
======= */ |
||||
|
||||
#ident \ |
||||
"Copyright (c) 2006, 2015, Percona and/or its affiliates. All rights reserved." |
||||
|
||||
#include "keyrange.h" |
||||
|
||||
#include "../util/dbt.h" |
||||
|
||||
namespace toku { |
||||
|
||||
// create a keyrange by borrowing the left and right dbt
|
||||
// pointers. no memory is copied. no checks for infinity needed.
|
||||
void keyrange::create(const DBT *left, const DBT *right) { |
||||
init_empty(); |
||||
m_left_key = left; |
||||
m_right_key = right; |
||||
} |
||||
|
||||
// destroy the key copies. if they were never set, then destroy does nothing.
|
||||
void keyrange::destroy(void) { |
||||
toku_destroy_dbt(&m_left_key_copy); |
||||
toku_destroy_dbt(&m_right_key_copy); |
||||
} |
||||
|
||||
// create a keyrange by copying the keys from the given range.
|
||||
void keyrange::create_copy(const keyrange &range) { |
||||
// start with an initialized, empty range
|
||||
init_empty(); |
||||
|
||||
// optimize the case where the left and right keys are the same.
|
||||
// we'd like to only have one copy of the data.
|
||||
if (toku_dbt_equals(range.get_left_key(), range.get_right_key())) { |
||||
set_both_keys(range.get_left_key()); |
||||
} else { |
||||
// replace our empty left and right keys with
|
||||
// copies of the range's left and right keys
|
||||
replace_left_key(range.get_left_key()); |
||||
replace_right_key(range.get_right_key()); |
||||
} |
||||
} |
||||
|
||||
// extend this keyrange by choosing the leftmost and rightmost
|
||||
// endpoints between this range and the given. replaced keys
|
||||
// in this range are freed and inherited keys are copied.
|
||||
void keyrange::extend(const comparator &cmp, const keyrange &range) { |
||||
const DBT *range_left = range.get_left_key(); |
||||
const DBT *range_right = range.get_right_key(); |
||||
if (cmp(range_left, get_left_key()) < 0) { |
||||
replace_left_key(range_left); |
||||
} |
||||
if (cmp(range_right, get_right_key()) > 0) { |
||||
replace_right_key(range_right); |
||||
} |
||||
} |
||||
|
||||
// how much memory does this keyrange take?
|
||||
// - the size of the left and right keys
|
||||
// --- ignore the fact that we may have optimized the point case.
|
||||
// it complicates things for little gain.
|
||||
// - the size of the keyrange class itself
|
||||
uint64_t keyrange::get_memory_size(void) const { |
||||
const DBT *left_key = get_left_key(); |
||||
const DBT *right_key = get_right_key(); |
||||
return left_key->size + right_key->size + sizeof(keyrange); |
||||
} |
||||
|
||||
// compare ranges.
|
||||
keyrange::comparison keyrange::compare(const comparator &cmp, |
||||
const keyrange &range) const { |
||||
if (cmp(get_right_key(), range.get_left_key()) < 0) { |
||||
return comparison::LESS_THAN; |
||||
} else if (cmp(get_left_key(), range.get_right_key()) > 0) { |
||||
return comparison::GREATER_THAN; |
||||
} else if (cmp(get_left_key(), range.get_left_key()) == 0 && |
||||
cmp(get_right_key(), range.get_right_key()) == 0) { |
||||
return comparison::EQUALS; |
||||
} else { |
||||
return comparison::OVERLAPS; |
||||
} |
||||
} |
||||
|
||||
bool keyrange::overlaps(const comparator &cmp, const keyrange &range) const { |
||||
// equality is a stronger form of overlapping.
|
||||
// so two ranges "overlap" if they're either equal or just overlapping.
|
||||
comparison c = compare(cmp, range); |
||||
return c == comparison::EQUALS || c == comparison::OVERLAPS; |
||||
} |
||||
|
||||
keyrange keyrange::get_infinite_range(void) { |
||||
keyrange range; |
||||
range.create(toku_dbt_negative_infinity(), toku_dbt_positive_infinity()); |
||||
return range; |
||||
} |
||||
|
||||
void keyrange::init_empty(void) { |
||||
m_left_key = nullptr; |
||||
m_right_key = nullptr; |
||||
toku_init_dbt(&m_left_key_copy); |
||||
toku_init_dbt(&m_right_key_copy); |
||||
m_point_range = false; |
||||
} |
||||
|
||||
const DBT *keyrange::get_left_key(void) const { |
||||
if (m_left_key) { |
||||
return m_left_key; |
||||
} else { |
||||
return &m_left_key_copy; |
||||
} |
||||
} |
||||
|
||||
const DBT *keyrange::get_right_key(void) const { |
||||
if (m_right_key) { |
||||
return m_right_key; |
||||
} else { |
||||
return &m_right_key_copy; |
||||
} |
||||
} |
||||
|
||||
// copy the given once and set both the left and right pointers.
|
||||
// optimization for point ranges, so the left and right ranges
|
||||
// are not copied twice.
|
||||
void keyrange::set_both_keys(const DBT *key) { |
||||
if (toku_dbt_is_infinite(key)) { |
||||
m_left_key = key; |
||||
m_right_key = key; |
||||
} else { |
||||
toku_clone_dbt(&m_left_key_copy, *key); |
||||
toku_copyref_dbt(&m_right_key_copy, m_left_key_copy); |
||||
} |
||||
m_point_range = true; |
||||
} |
||||
|
||||
// destroy the current left key. set and possibly copy the new one
|
||||
void keyrange::replace_left_key(const DBT *key) { |
||||
// a little magic:
|
||||
//
|
||||
// if this is a point range, then the left and right keys share
|
||||
// one copy of the data, and it lives in the left key copy. so
|
||||
// if we're replacing the left key, move the real data to the
|
||||
// right key copy instead of destroying it. now, the memory is
|
||||
// owned by the right key and the left key may be replaced.
|
||||
if (m_point_range) { |
||||
m_right_key_copy = m_left_key_copy; |
||||
} else { |
||||
toku_destroy_dbt(&m_left_key_copy); |
||||
} |
||||
|
||||
if (toku_dbt_is_infinite(key)) { |
||||
m_left_key = key; |
||||
} else { |
||||
toku_clone_dbt(&m_left_key_copy, *key); |
||||
m_left_key = nullptr; |
||||
} |
||||
m_point_range = false; |
||||
} |
||||
|
||||
// destroy the current right key. set and possibly copy the new one
|
||||
void keyrange::replace_right_key(const DBT *key) { |
||||
toku_destroy_dbt(&m_right_key_copy); |
||||
if (toku_dbt_is_infinite(key)) { |
||||
m_right_key = key; |
||||
} else { |
||||
toku_clone_dbt(&m_right_key_copy, *key); |
||||
m_right_key = nullptr; |
||||
} |
||||
m_point_range = false; |
||||
} |
||||
|
||||
} /* namespace toku */ |
||||
#endif // OS_WIN
|
||||
#endif // ROCKSDB_LITE
|
||||
@ -0,0 +1,140 @@ |
||||
/* -*- mode: C++; c-basic-offset: 4; indent-tabs-mode: nil -*- */ |
||||
// vim: ft=cpp:expandtab:ts=8:sw=4:softtabstop=4:
|
||||
#ident "$Id$" |
||||
/*======
|
||||
This file is part of PerconaFT. |
||||
|
||||
|
||||
Copyright (c) 2006, 2015, Percona and/or its affiliates. All rights reserved. |
||||
|
||||
PerconaFT is free software: you can redistribute it and/or modify |
||||
it under the terms of the GNU General Public License, version 2, |
||||
as published by the Free Software Foundation. |
||||
|
||||
PerconaFT is distributed in the hope that it will be useful, |
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
GNU General Public License for more details. |
||||
|
||||
You should have received a copy of the GNU General Public License |
||||
along with PerconaFT. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
---------------------------------------- |
||||
|
||||
PerconaFT is free software: you can redistribute it and/or modify |
||||
it under the terms of the GNU Affero General Public License, version 3, |
||||
as published by the Free Software Foundation. |
||||
|
||||
PerconaFT is distributed in the hope that it will be useful, |
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
GNU Affero General Public License for more details. |
||||
|
||||
You should have received a copy of the GNU Affero General Public License |
||||
along with PerconaFT. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
---------------------------------------- |
||||
|
||||
Licensed under the Apache License, Version 2.0 (the "License"); |
||||
you may not use this file except in compliance with the License. |
||||
You may obtain a copy of the License at |
||||
|
||||
http://www.apache.org/licenses/LICENSE-2.0
|
||||
|
||||
Unless required by applicable law or agreed to in writing, software |
||||
distributed under the License is distributed on an "AS IS" BASIS, |
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
||||
See the License for the specific language governing permissions and |
||||
======= */ |
||||
|
||||
#ident \ |
||||
"Copyright (c) 2006, 2015, Percona and/or its affiliates. All rights reserved." |
||||
|
||||
#pragma once |
||||
|
||||
#include "../ft/comparator.h" |
||||
|
||||
namespace toku { |
||||
|
||||
// A keyrange has a left and right key as endpoints.
|
||||
//
|
||||
// When a keyrange is created it owns no memory, but when it copies
|
||||
// or extends another keyrange, it copies memory as necessary. This
|
||||
// means it is cheap in the common case.
|
||||
|
||||
class keyrange { |
||||
public: |
||||
// effect: constructor that borrows left and right key pointers.
|
||||
// no memory is allocated or copied.
|
||||
void create(const DBT *left_key, const DBT *right_key); |
||||
|
||||
// effect: constructor that allocates and copies another keyrange's points.
|
||||
void create_copy(const keyrange &range); |
||||
|
||||
// effect: destroys the keyrange, freeing any allocated memory
|
||||
void destroy(void); |
||||
|
||||
// effect: extends the keyrange by choosing the leftmost and rightmost
|
||||
// endpoints from this range and the given range.
|
||||
// replaced keys in this range are freed, new keys are copied.
|
||||
void extend(const comparator &cmp, const keyrange &range); |
||||
|
||||
// returns: the amount of memory this keyrange takes. does not account
|
||||
// for point optimizations or malloc overhead.
|
||||
uint64_t get_memory_size(void) const; |
||||
|
||||
// returns: pointer to the left key of this range
|
||||
const DBT *get_left_key(void) const; |
||||
|
||||
// returns: pointer to the right key of this range
|
||||
const DBT *get_right_key(void) const; |
||||
|
||||
// two ranges are either equal, lt, gt, or overlapping
|
||||
enum comparison { EQUALS, LESS_THAN, GREATER_THAN, OVERLAPS }; |
||||
|
||||
// effect: compares this range to the given range
|
||||
// returns: LESS_THAN if given range is strictly to the left
|
||||
// GREATER_THAN if given range is strictly to the right
|
||||
// EQUALS if given range has the same left and right endpoints
|
||||
// OVERLAPS if at least one of the given range's endpoints falls
|
||||
// between this range's endpoints
|
||||
comparison compare(const comparator &cmp, const keyrange &range) const; |
||||
|
||||
// returns: true if the range and the given range are equal or overlapping
|
||||
bool overlaps(const comparator &cmp, const keyrange &range) const; |
||||
|
||||
// returns: a keyrange representing -inf, +inf
|
||||
static keyrange get_infinite_range(void); |
||||
|
||||
private: |
||||
// some keys should be copied, some keys should not be.
|
||||
//
|
||||
// to support both, we use two DBTs for copies and two pointers
|
||||
// for temporaries. the access rule is:
|
||||
// - if a pointer is non-null, then it reprsents the key.
|
||||
// - otherwise the pointer is null, and the key is in the copy.
|
||||
DBT m_left_key_copy; |
||||
DBT m_right_key_copy; |
||||
const DBT *m_left_key; |
||||
const DBT *m_right_key; |
||||
|
||||
// if this range is a point range, then m_left_key == m_right_key
|
||||
// and the actual data is stored exactly once in m_left_key_copy.
|
||||
bool m_point_range; |
||||
|
||||
// effect: initializes a keyrange to be empty
|
||||
void init_empty(void); |
||||
|
||||
// effect: copies the given key once into the left key copy
|
||||
// and sets the right key copy to share the left.
|
||||
// rationale: optimization for point ranges to only do one malloc
|
||||
void set_both_keys(const DBT *key); |
||||
|
||||
// effect: destroys the current left key. sets and copies the new one.
|
||||
void replace_left_key(const DBT *key); |
||||
|
||||
// effect: destroys the current right key. sets and copies the new one.
|
||||
void replace_right_key(const DBT *key); |
||||
}; |
||||
|
||||
} /* namespace toku */ |
||||
@ -0,0 +1,534 @@ |
||||
/* -*- mode: C++; c-basic-offset: 4; indent-tabs-mode: nil -*- */ |
||||
// vim: ft=cpp:expandtab:ts=8:sw=4:softtabstop=4:
|
||||
#ifndef ROCKSDB_LITE |
||||
#ifndef OS_WIN |
||||
#ident "$Id$" |
||||
/*======
|
||||
This file is part of PerconaFT. |
||||
|
||||
|
||||
Copyright (c) 2006, 2015, Percona and/or its affiliates. All rights reserved. |
||||
|
||||
PerconaFT is free software: you can redistribute it and/or modify |
||||
it under the terms of the GNU General Public License, version 2, |
||||
as published by the Free Software Foundation. |
||||
|
||||
PerconaFT is distributed in the hope that it will be useful, |
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
GNU General Public License for more details. |
||||
|
||||
You should have received a copy of the GNU General Public License |
||||
along with PerconaFT. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
---------------------------------------- |
||||
|
||||
PerconaFT is free software: you can redistribute it and/or modify |
||||
it under the terms of the GNU Affero General Public License, version 3, |
||||
as published by the Free Software Foundation. |
||||
|
||||
PerconaFT is distributed in the hope that it will be useful, |
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
GNU Affero General Public License for more details. |
||||
|
||||
You should have received a copy of the GNU Affero General Public License |
||||
along with PerconaFT. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
---------------------------------------- |
||||
|
||||
Licensed under the Apache License, Version 2.0 (the "License"); |
||||
you may not use this file except in compliance with the License. |
||||
You may obtain a copy of the License at |
||||
|
||||
http://www.apache.org/licenses/LICENSE-2.0
|
||||
|
||||
Unless required by applicable law or agreed to in writing, software |
||||
distributed under the License is distributed on an "AS IS" BASIS, |
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
||||
See the License for the specific language governing permissions and |
||||
======= */ |
||||
|
||||
#ident \ |
||||
"Copyright (c) 2006, 2015, Percona and/or its affiliates. All rights reserved." |
||||
|
||||
#include "lock_request.h" |
||||
|
||||
#include "../portability/toku_race_tools.h" |
||||
#include "../portability/txn_subst.h" |
||||
#include "../util/dbt.h" |
||||
#include "locktree.h" |
||||
|
||||
namespace toku { |
||||
|
||||
// initialize a lock request's internals
|
||||
void lock_request::create(toku_external_mutex_factory_t mutex_factory) { |
||||
m_txnid = TXNID_NONE; |
||||
m_conflicting_txnid = TXNID_NONE; |
||||
m_start_time = 0; |
||||
m_left_key = nullptr; |
||||
m_right_key = nullptr; |
||||
toku_init_dbt(&m_left_key_copy); |
||||
toku_init_dbt(&m_right_key_copy); |
||||
|
||||
m_type = type::UNKNOWN; |
||||
m_lt = nullptr; |
||||
|
||||
m_complete_r = 0; |
||||
m_state = state::UNINITIALIZED; |
||||
m_info = nullptr; |
||||
|
||||
// psergey-todo: this condition is for interruptible wait
|
||||
// note: moved to here from lock_request::create:
|
||||
toku_external_cond_init(mutex_factory, &m_wait_cond); |
||||
|
||||
m_start_test_callback = nullptr; |
||||
m_start_before_pending_test_callback = nullptr; |
||||
m_retry_test_callback = nullptr; |
||||
} |
||||
|
||||
// destroy a lock request.
|
||||
void lock_request::destroy(void) { |
||||
invariant(m_state != state::PENDING); |
||||
invariant(m_state != state::DESTROYED); |
||||
m_state = state::DESTROYED; |
||||
toku_destroy_dbt(&m_left_key_copy); |
||||
toku_destroy_dbt(&m_right_key_copy); |
||||
toku_external_cond_destroy(&m_wait_cond); |
||||
} |
||||
|
||||
// set the lock request parameters. this API allows a lock request to be reused.
|
||||
void lock_request::set(locktree *lt, TXNID txnid, const DBT *left_key, |
||||
const DBT *right_key, lock_request::type lock_type, |
||||
bool big_txn, void *extra) { |
||||
invariant(m_state != state::PENDING); |
||||
m_lt = lt; |
||||
|
||||
m_txnid = txnid; |
||||
m_left_key = left_key; |
||||
m_right_key = right_key; |
||||
toku_destroy_dbt(&m_left_key_copy); |
||||
toku_destroy_dbt(&m_right_key_copy); |
||||
m_type = lock_type; |
||||
m_state = state::INITIALIZED; |
||||
m_info = lt ? lt->get_lock_request_info() : nullptr; |
||||
m_big_txn = big_txn; |
||||
m_extra = extra; |
||||
} |
||||
|
||||
// get rid of any stored left and right key copies and
|
||||
// replace them with copies of the given left and right key
|
||||
void lock_request::copy_keys() { |
||||
if (!toku_dbt_is_infinite(m_left_key)) { |
||||
toku_clone_dbt(&m_left_key_copy, *m_left_key); |
||||
m_left_key = &m_left_key_copy; |
||||
} |
||||
if (!toku_dbt_is_infinite(m_right_key)) { |
||||
toku_clone_dbt(&m_right_key_copy, *m_right_key); |
||||
m_right_key = &m_right_key_copy; |
||||
} |
||||
} |
||||
|
||||
// what are the conflicts for this pending lock request?
|
||||
void lock_request::get_conflicts(txnid_set *conflicts) { |
||||
invariant(m_state == state::PENDING); |
||||
const bool is_write_request = m_type == type::WRITE; |
||||
m_lt->get_conflicts(is_write_request, m_txnid, m_left_key, m_right_key, |
||||
conflicts); |
||||
} |
||||
|
||||
// build a wait-for-graph for this lock request and the given conflict set
|
||||
// for each transaction B that blocks A's lock request
|
||||
// if B is blocked then
|
||||
// add (A,T) to the WFG and if B is new, fill in the WFG from B
|
||||
void lock_request::build_wait_graph(wfg *wait_graph, |
||||
const txnid_set &conflicts) { |
||||
uint32_t num_conflicts = conflicts.size(); |
||||
for (uint32_t i = 0; i < num_conflicts; i++) { |
||||
TXNID conflicting_txnid = conflicts.get(i); |
||||
lock_request *conflicting_request = find_lock_request(conflicting_txnid); |
||||
invariant(conflicting_txnid != m_txnid); |
||||
invariant(conflicting_request != this); |
||||
if (conflicting_request) { |
||||
bool already_exists = wait_graph->node_exists(conflicting_txnid); |
||||
wait_graph->add_edge(m_txnid, conflicting_txnid); |
||||
if (!already_exists) { |
||||
// recursively build the wait for graph rooted at the conflicting
|
||||
// request, given its set of lock conflicts.
|
||||
txnid_set other_conflicts; |
||||
other_conflicts.create(); |
||||
conflicting_request->get_conflicts(&other_conflicts); |
||||
conflicting_request->build_wait_graph(wait_graph, other_conflicts); |
||||
other_conflicts.destroy(); |
||||
} |
||||
} |
||||
} |
||||
} |
||||
|
||||
// returns: true if the current set of lock requests contains
|
||||
// a deadlock, false otherwise.
|
||||
bool lock_request::deadlock_exists(const txnid_set &conflicts) { |
||||
wfg wait_graph; |
||||
wait_graph.create(); |
||||
|
||||
build_wait_graph(&wait_graph, conflicts); |
||||
|
||||
std::function<void(TXNID)> reporter; |
||||
if (m_deadlock_cb) { |
||||
reporter = [this](TXNID a) { |
||||
lock_request *req = find_lock_request(a); |
||||
if (req) { |
||||
m_deadlock_cb(req->m_txnid, (req->m_type == lock_request::WRITE), |
||||
req->m_left_key, req->m_right_key); |
||||
} |
||||
}; |
||||
} |
||||
|
||||
bool deadlock = wait_graph.cycle_exists_from_txnid(m_txnid, reporter); |
||||
wait_graph.destroy(); |
||||
return deadlock; |
||||
} |
||||
|
||||
// try to acquire a lock described by this lock request.
|
||||
int lock_request::start(void) { |
||||
int r; |
||||
|
||||
txnid_set conflicts; |
||||
conflicts.create(); |
||||
if (m_type == type::WRITE) { |
||||
r = m_lt->acquire_write_lock(m_txnid, m_left_key, m_right_key, &conflicts, |
||||
m_big_txn); |
||||
} else { |
||||
invariant(m_type == type::READ); |
||||
r = m_lt->acquire_read_lock(m_txnid, m_left_key, m_right_key, &conflicts, |
||||
m_big_txn); |
||||
} |
||||
|
||||
// if the lock is not granted, save it to the set of lock requests
|
||||
// and check for a deadlock. if there is one, complete it as failed
|
||||
if (r == DB_LOCK_NOTGRANTED) { |
||||
copy_keys(); |
||||
m_state = state::PENDING; |
||||
m_start_time = toku_current_time_microsec() / 1000; |
||||
m_conflicting_txnid = conflicts.get(0); |
||||
if (m_start_before_pending_test_callback) |
||||
m_start_before_pending_test_callback(); |
||||
toku_external_mutex_lock(&m_info->mutex); |
||||
insert_into_lock_requests(); |
||||
if (deadlock_exists(conflicts)) { |
||||
remove_from_lock_requests(); |
||||
r = DB_LOCK_DEADLOCK; |
||||
} |
||||
toku_external_mutex_unlock(&m_info->mutex); |
||||
if (m_start_test_callback) m_start_test_callback(); // test callback
|
||||
} |
||||
|
||||
if (r != DB_LOCK_NOTGRANTED) { |
||||
complete(r); |
||||
} |
||||
|
||||
conflicts.destroy(); |
||||
return r; |
||||
} |
||||
|
||||
// sleep on the lock request until it becomes resolved or the wait time has
|
||||
// elapsed.
|
||||
int lock_request::wait(uint64_t wait_time_ms) { |
||||
return wait(wait_time_ms, 0, nullptr); |
||||
} |
||||
|
||||
int lock_request::wait(uint64_t wait_time_ms, uint64_t killed_time_ms, |
||||
int (*killed_callback)(void), |
||||
void (*lock_wait_callback)(void *, TXNID, TXNID), |
||||
void *callback_arg) { |
||||
uint64_t t_now = toku_current_time_microsec(); |
||||
uint64_t t_start = t_now; |
||||
uint64_t t_end = t_start + wait_time_ms * 1000; |
||||
|
||||
toku_external_mutex_lock(&m_info->mutex); |
||||
|
||||
// check again, this time locking out other retry calls
|
||||
if (m_state == state::PENDING) { |
||||
GrowableArray<TXNID> conflicts_collector; |
||||
conflicts_collector.init(); |
||||
retry(&conflicts_collector); |
||||
if (m_state == state::PENDING) { |
||||
report_waits(&conflicts_collector, lock_wait_callback, callback_arg); |
||||
} |
||||
conflicts_collector.deinit(); |
||||
} |
||||
|
||||
while (m_state == state::PENDING) { |
||||
// check if this thread is killed
|
||||
if (killed_callback && killed_callback()) { |
||||
remove_from_lock_requests(); |
||||
complete(DB_LOCK_NOTGRANTED); |
||||
continue; |
||||
} |
||||
|
||||
// compute the time until we should wait
|
||||
uint64_t t_wait; |
||||
if (killed_time_ms == 0) { |
||||
t_wait = t_end; |
||||
} else { |
||||
t_wait = t_now + killed_time_ms * 1000; |
||||
if (t_wait > t_end) t_wait = t_end; |
||||
} |
||||
|
||||
int r = toku_external_cond_timedwait(&m_wait_cond, &m_info->mutex, |
||||
(int64_t)(t_wait - t_now)); |
||||
invariant(r == 0 || r == ETIMEDOUT); |
||||
|
||||
t_now = toku_current_time_microsec(); |
||||
if (m_state == state::PENDING && (t_now >= t_end)) { |
||||
m_info->counters.timeout_count += 1; |
||||
|
||||
// if we're still pending and we timed out, then remove our
|
||||
// request from the set of lock requests and fail.
|
||||
remove_from_lock_requests(); |
||||
|
||||
// complete sets m_state to COMPLETE, breaking us out of the loop
|
||||
complete(DB_LOCK_NOTGRANTED); |
||||
} |
||||
} |
||||
|
||||
uint64_t t_real_end = toku_current_time_microsec(); |
||||
uint64_t duration = t_real_end - t_start; |
||||
m_info->counters.wait_count += 1; |
||||
m_info->counters.wait_time += duration; |
||||
if (duration >= 1000000) { |
||||
m_info->counters.long_wait_count += 1; |
||||
m_info->counters.long_wait_time += duration; |
||||
} |
||||
toku_external_mutex_unlock(&m_info->mutex); |
||||
|
||||
invariant(m_state == state::COMPLETE); |
||||
return m_complete_r; |
||||
} |
||||
|
||||
// complete this lock request with the given return value
|
||||
void lock_request::complete(int complete_r) { |
||||
m_complete_r = complete_r; |
||||
m_state = state::COMPLETE; |
||||
} |
||||
|
||||
const DBT *lock_request::get_left_key(void) const { return m_left_key; } |
||||
|
||||
const DBT *lock_request::get_right_key(void) const { return m_right_key; } |
||||
|
||||
TXNID lock_request::get_txnid(void) const { return m_txnid; } |
||||
|
||||
uint64_t lock_request::get_start_time(void) const { return m_start_time; } |
||||
|
||||
TXNID lock_request::get_conflicting_txnid(void) const { |
||||
return m_conflicting_txnid; |
||||
} |
||||
|
||||
int lock_request::retry(GrowableArray<TXNID> *conflicts_collector) { |
||||
invariant(m_state == state::PENDING); |
||||
int r; |
||||
txnid_set conflicts; |
||||
conflicts.create(); |
||||
|
||||
if (m_type == type::WRITE) { |
||||
r = m_lt->acquire_write_lock(m_txnid, m_left_key, m_right_key, &conflicts, |
||||
m_big_txn); |
||||
} else { |
||||
r = m_lt->acquire_read_lock(m_txnid, m_left_key, m_right_key, &conflicts, |
||||
m_big_txn); |
||||
} |
||||
|
||||
// if the acquisition succeeded then remove ourselves from the
|
||||
// set of lock requests, complete, and signal the waiting thread.
|
||||
if (r == 0) { |
||||
remove_from_lock_requests(); |
||||
complete(r); |
||||
if (m_retry_test_callback) m_retry_test_callback(); // test callback
|
||||
toku_external_cond_broadcast(&m_wait_cond); |
||||
} else { |
||||
m_conflicting_txnid = conflicts.get(0); |
||||
add_conflicts_to_waits(&conflicts, conflicts_collector); |
||||
} |
||||
conflicts.destroy(); |
||||
|
||||
return r; |
||||
} |
||||
|
||||
void lock_request::retry_all_lock_requests( |
||||
locktree *lt, void (*lock_wait_callback)(void *, TXNID, TXNID), |
||||
void *callback_arg, void (*after_retry_all_test_callback)(void)) { |
||||
lt_lock_request_info *info = lt->get_lock_request_info(); |
||||
|
||||
// if there are no pending lock requests than there is nothing to do
|
||||
// the unlocked data race on pending_is_empty is OK since lock requests
|
||||
// are retried after added to the pending set.
|
||||
if (info->pending_is_empty) return; |
||||
|
||||
// get my retry generation (post increment of retry_want)
|
||||
unsigned long long my_retry_want = (info->retry_want += 1); |
||||
|
||||
toku_mutex_lock(&info->retry_mutex); |
||||
|
||||
GrowableArray<TXNID> conflicts_collector; |
||||
conflicts_collector.init(); |
||||
|
||||
// here is the group retry algorithm.
|
||||
// get the latest retry_want count and use it as the generation number of
|
||||
// this retry operation. if this retry generation is > the last retry
|
||||
// generation, then do the lock retries. otherwise, no lock retries
|
||||
// are needed.
|
||||
if ((my_retry_want - 1) == info->retry_done) { |
||||
for (;;) { |
||||
if (!info->running_retry) { |
||||
info->running_retry = true; |
||||
info->retry_done = info->retry_want; |
||||
toku_mutex_unlock(&info->retry_mutex); |
||||
retry_all_lock_requests_info(info, &conflicts_collector); |
||||
if (after_retry_all_test_callback) after_retry_all_test_callback(); |
||||
toku_mutex_lock(&info->retry_mutex); |
||||
info->running_retry = false; |
||||
toku_cond_broadcast(&info->retry_cv); |
||||
break; |
||||
} else { |
||||
toku_cond_wait(&info->retry_cv, &info->retry_mutex); |
||||
} |
||||
} |
||||
} |
||||
toku_mutex_unlock(&info->retry_mutex); |
||||
|
||||
report_waits(&conflicts_collector, lock_wait_callback, callback_arg); |
||||
conflicts_collector.deinit(); |
||||
} |
||||
|
||||
void lock_request::retry_all_lock_requests_info( |
||||
lt_lock_request_info *info, GrowableArray<TXNID> *collector) { |
||||
toku_external_mutex_lock(&info->mutex); |
||||
// retry all of the pending lock requests.
|
||||
for (uint32_t i = 0; i < info->pending_lock_requests.size();) { |
||||
lock_request *request; |
||||
int r = info->pending_lock_requests.fetch(i, &request); |
||||
invariant_zero(r); |
||||
|
||||
// retry the lock request. if it didn't succeed,
|
||||
// move on to the next lock request. otherwise
|
||||
// the request is gone from the list so we may
|
||||
// read the i'th entry for the next one.
|
||||
r = request->retry(collector); |
||||
if (r != 0) { |
||||
i++; |
||||
} |
||||
} |
||||
|
||||
// future threads should only retry lock requests if some still exist
|
||||
info->should_retry_lock_requests = info->pending_lock_requests.size() > 0; |
||||
toku_external_mutex_unlock(&info->mutex); |
||||
} |
||||
|
||||
void lock_request::add_conflicts_to_waits( |
||||
txnid_set *conflicts, GrowableArray<TXNID> *wait_conflicts) { |
||||
uint32_t num_conflicts = conflicts->size(); |
||||
for (uint32_t i = 0; i < num_conflicts; i++) { |
||||
wait_conflicts->push(m_txnid); |
||||
wait_conflicts->push(conflicts->get(i)); |
||||
} |
||||
} |
||||
|
||||
void lock_request::report_waits(GrowableArray<TXNID> *wait_conflicts, |
||||
void (*lock_wait_callback)(void *, TXNID, |
||||
TXNID), |
||||
void *callback_arg) { |
||||
if (!lock_wait_callback) return; |
||||
size_t num_conflicts = wait_conflicts->get_size(); |
||||
for (size_t i = 0; i < num_conflicts; i += 2) { |
||||
TXNID blocked_txnid = wait_conflicts->fetch_unchecked(i); |
||||
TXNID blocking_txnid = wait_conflicts->fetch_unchecked(i + 1); |
||||
(*lock_wait_callback)(callback_arg, blocked_txnid, blocking_txnid); |
||||
} |
||||
} |
||||
|
||||
void *lock_request::get_extra(void) const { return m_extra; } |
||||
|
||||
void lock_request::kill_waiter(void) { |
||||
remove_from_lock_requests(); |
||||
complete(DB_LOCK_NOTGRANTED); |
||||
toku_external_cond_broadcast(&m_wait_cond); |
||||
} |
||||
|
||||
void lock_request::kill_waiter(locktree *lt, void *extra) { |
||||
lt_lock_request_info *info = lt->get_lock_request_info(); |
||||
toku_external_mutex_lock(&info->mutex); |
||||
for (uint32_t i = 0; i < info->pending_lock_requests.size(); i++) { |
||||
lock_request *request; |
||||
int r = info->pending_lock_requests.fetch(i, &request); |
||||
if (r == 0 && request->get_extra() == extra) { |
||||
request->kill_waiter(); |
||||
break; |
||||
} |
||||
} |
||||
toku_external_mutex_unlock(&info->mutex); |
||||
} |
||||
|
||||
// find another lock request by txnid. must hold the mutex.
|
||||
lock_request *lock_request::find_lock_request(const TXNID &txnid) { |
||||
lock_request *request; |
||||
int r = m_info->pending_lock_requests.find_zero<TXNID, find_by_txnid>( |
||||
txnid, &request, nullptr); |
||||
if (r != 0) { |
||||
request = nullptr; |
||||
} |
||||
return request; |
||||
} |
||||
|
||||
// insert this lock request into the locktree's set. must hold the mutex.
|
||||
void lock_request::insert_into_lock_requests(void) { |
||||
uint32_t idx; |
||||
lock_request *request; |
||||
int r = m_info->pending_lock_requests.find_zero<TXNID, find_by_txnid>( |
||||
m_txnid, &request, &idx); |
||||
invariant(r == DB_NOTFOUND); |
||||
r = m_info->pending_lock_requests.insert_at(this, idx); |
||||
invariant_zero(r); |
||||
m_info->pending_is_empty = false; |
||||
} |
||||
|
||||
// remove this lock request from the locktree's set. must hold the mutex.
|
||||
void lock_request::remove_from_lock_requests(void) { |
||||
uint32_t idx; |
||||
lock_request *request; |
||||
int r = m_info->pending_lock_requests.find_zero<TXNID, find_by_txnid>( |
||||
m_txnid, &request, &idx); |
||||
invariant_zero(r); |
||||
invariant(request == this); |
||||
r = m_info->pending_lock_requests.delete_at(idx); |
||||
invariant_zero(r); |
||||
if (m_info->pending_lock_requests.size() == 0) |
||||
m_info->pending_is_empty = true; |
||||
} |
||||
|
||||
int lock_request::find_by_txnid(lock_request *const &request, |
||||
const TXNID &txnid) { |
||||
TXNID request_txnid = request->m_txnid; |
||||
if (request_txnid < txnid) { |
||||
return -1; |
||||
} else if (request_txnid == txnid) { |
||||
return 0; |
||||
} else { |
||||
return 1; |
||||
} |
||||
} |
||||
|
||||
void lock_request::set_start_test_callback(void (*f)(void)) { |
||||
m_start_test_callback = f; |
||||
} |
||||
|
||||
void lock_request::set_start_before_pending_test_callback(void (*f)(void)) { |
||||
m_start_before_pending_test_callback = f; |
||||
} |
||||
|
||||
void lock_request::set_retry_test_callback(void (*f)(void)) { |
||||
m_retry_test_callback = f; |
||||
} |
||||
|
||||
} /* namespace toku */ |
||||
#endif // OS_WIN
|
||||
#endif // ROCKSDB_LITE
|
||||
@ -0,0 +1,238 @@ |
||||
/* -*- mode: C++; c-basic-offset: 4; indent-tabs-mode: nil -*- */ |
||||
// vim: ft=cpp:expandtab:ts=8:sw=4:softtabstop=4:
|
||||
#ident "$Id$" |
||||
/*======
|
||||
This file is part of PerconaFT. |
||||
|
||||
|
||||
Copyright (c) 2006, 2015, Percona and/or its affiliates. All rights reserved. |
||||
|
||||
PerconaFT is free software: you can redistribute it and/or modify |
||||
it under the terms of the GNU General Public License, version 2, |
||||
as published by the Free Software Foundation. |
||||
|
||||
PerconaFT is distributed in the hope that it will be useful, |
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
GNU General Public License for more details. |
||||
|
||||
You should have received a copy of the GNU General Public License |
||||
along with PerconaFT. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
---------------------------------------- |
||||
|
||||
PerconaFT is free software: you can redistribute it and/or modify |
||||
it under the terms of the GNU Affero General Public License, version 3, |
||||
as published by the Free Software Foundation. |
||||
|
||||
PerconaFT is distributed in the hope that it will be useful, |
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
GNU Affero General Public License for more details. |
||||
|
||||
You should have received a copy of the GNU Affero General Public License |
||||
along with PerconaFT. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
---------------------------------------- |
||||
|
||||
Licensed under the Apache License, Version 2.0 (the "License"); |
||||
you may not use this file except in compliance with the License. |
||||
You may obtain a copy of the License at |
||||
|
||||
http://www.apache.org/licenses/LICENSE-2.0
|
||||
|
||||
Unless required by applicable law or agreed to in writing, software |
||||
distributed under the License is distributed on an "AS IS" BASIS, |
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
||||
See the License for the specific language governing permissions and |
||||
======= */ |
||||
|
||||
#ident \ |
||||
"Copyright (c) 2006, 2015, Percona and/or its affiliates. All rights reserved." |
||||
|
||||
#pragma once |
||||
|
||||
#include "../db.h" |
||||
#include "../ft/comparator.h" |
||||
#include "../portability/toku_pthread.h" |
||||
#include "locktree.h" |
||||
#include "txnid_set.h" |
||||
#include "wfg.h" |
||||
|
||||
namespace toku { |
||||
|
||||
// A lock request contains the db, the key range, the lock type, and
|
||||
// the transaction id that describes a potential row range lock.
|
||||
//
|
||||
// the typical use case is:
|
||||
// - initialize a lock request
|
||||
// - start to try to acquire the lock
|
||||
// - do something else
|
||||
// - wait for the lock request to be resolved on a timed condition
|
||||
// - destroy the lock request
|
||||
// a lock request is resolved when its state is no longer pending, or
|
||||
// when it becomes granted, or timedout, or deadlocked. when resolved, the
|
||||
// state of the lock request is changed and any waiting threads are awakened.
|
||||
|
||||
class lock_request { |
||||
public: |
||||
enum type { UNKNOWN, READ, WRITE }; |
||||
|
||||
// effect: Initializes a lock request.
|
||||
void create(toku_external_mutex_factory_t mutex_factory); |
||||
|
||||
// effect: Destroys a lock request.
|
||||
void destroy(void); |
||||
|
||||
// effect: Resets the lock request parameters, allowing it to be reused.
|
||||
// requires: Lock request was already created at some point
|
||||
void set(locktree *lt, TXNID txnid, const DBT *left_key, const DBT *right_key, |
||||
type lock_type, bool big_txn, void *extra = nullptr); |
||||
|
||||
// effect: Tries to acquire a lock described by this lock request.
|
||||
// returns: The return code of locktree::acquire_[write,read]_lock()
|
||||
// or DB_LOCK_DEADLOCK if this request would end up deadlocked.
|
||||
int start(void); |
||||
|
||||
// effect: Sleeps until either the request is granted or the wait time
|
||||
// expires. returns: The return code of locktree::acquire_[write,read]_lock()
|
||||
// or simply DB_LOCK_NOTGRANTED if the wait time expired.
|
||||
int wait(uint64_t wait_time_ms); |
||||
int wait(uint64_t wait_time_ms, uint64_t killed_time_ms, |
||||
int (*killed_callback)(void), |
||||
void (*lock_wait_callback)(void *, TXNID, TXNID) = nullptr, |
||||
void *callback_arg = nullptr); |
||||
|
||||
// return: left end-point of the lock range
|
||||
const DBT *get_left_key(void) const; |
||||
|
||||
// return: right end-point of the lock range
|
||||
const DBT *get_right_key(void) const; |
||||
|
||||
// return: the txnid waiting for a lock
|
||||
TXNID get_txnid(void) const; |
||||
|
||||
// return: when this lock request started, as milliseconds from epoch
|
||||
uint64_t get_start_time(void) const; |
||||
|
||||
// return: which txnid is blocking this request (there may be more, though)
|
||||
TXNID get_conflicting_txnid(void) const; |
||||
|
||||
// effect: Retries all of the lock requests for the given locktree.
|
||||
// Any lock requests successfully restarted is completed and woken
|
||||
// up.
|
||||
// The rest remain pending.
|
||||
static void retry_all_lock_requests( |
||||
locktree *lt, void (*lock_wait_callback)(void *, TXNID, TXNID) = nullptr, |
||||
void *callback_arg = nullptr, |
||||
void (*after_retry_test_callback)(void) = nullptr); |
||||
static void retry_all_lock_requests_info(lt_lock_request_info *info, |
||||
GrowableArray<TXNID> *collector); |
||||
|
||||
void set_start_test_callback(void (*f)(void)); |
||||
void set_start_before_pending_test_callback(void (*f)(void)); |
||||
void set_retry_test_callback(void (*f)(void)); |
||||
|
||||
void *get_extra(void) const; |
||||
|
||||
void kill_waiter(void); |
||||
static void kill_waiter(locktree *lt, void *extra); |
||||
|
||||
private: |
||||
enum state { |
||||
UNINITIALIZED, |
||||
INITIALIZED, |
||||
PENDING, |
||||
COMPLETE, |
||||
DESTROYED, |
||||
}; |
||||
|
||||
// The keys for a lock request are stored "unowned" in m_left_key
|
||||
// and m_right_key. When the request is about to go to sleep, it
|
||||
// copies these keys and stores them in m_left_key_copy etc and
|
||||
// sets the temporary pointers to null.
|
||||
TXNID m_txnid; |
||||
TXNID m_conflicting_txnid; |
||||
uint64_t m_start_time; |
||||
const DBT *m_left_key; |
||||
const DBT *m_right_key; |
||||
DBT m_left_key_copy; |
||||
DBT m_right_key_copy; |
||||
|
||||
// The lock request type and associated locktree
|
||||
type m_type; |
||||
locktree *m_lt; |
||||
|
||||
// If the lock request is in the completed state, then its
|
||||
// final return value is stored in m_complete_r
|
||||
int m_complete_r; |
||||
state m_state; |
||||
|
||||
toku_external_cond_t m_wait_cond; |
||||
|
||||
bool m_big_txn; |
||||
|
||||
// the lock request info state stored in the
|
||||
// locktree that this lock request is for.
|
||||
struct lt_lock_request_info *m_info; |
||||
|
||||
void *m_extra; |
||||
|
||||
// effect: tries again to acquire the lock described by this lock request
|
||||
// returns: 0 if retrying the request succeeded and is now complete
|
||||
int retry(GrowableArray<TXNID> *conflict_collector); |
||||
|
||||
void complete(int complete_r); |
||||
|
||||
// effect: Finds another lock request by txnid.
|
||||
// requires: The lock request info mutex is held
|
||||
lock_request *find_lock_request(const TXNID &txnid); |
||||
|
||||
// effect: Insert this lock request into the locktree's set.
|
||||
// requires: the locktree's mutex is held
|
||||
void insert_into_lock_requests(void); |
||||
|
||||
// effect: Removes this lock request from the locktree's set.
|
||||
// requires: The lock request info mutex is held
|
||||
void remove_from_lock_requests(void); |
||||
|
||||
// effect: Asks this request's locktree which txnids are preventing
|
||||
// us from getting the lock described by this request.
|
||||
// returns: conflicts is populated with the txnid's that this request
|
||||
// is blocked on
|
||||
void get_conflicts(txnid_set *conflicts); |
||||
|
||||
// effect: Builds a wait-for-graph for this lock request and the given
|
||||
// conflict set
|
||||
void build_wait_graph(wfg *wait_graph, const txnid_set &conflicts); |
||||
|
||||
// returns: True if this lock request is in deadlock with the given conflicts
|
||||
// set
|
||||
bool deadlock_exists(const txnid_set &conflicts); |
||||
|
||||
void copy_keys(void); |
||||
|
||||
static int find_by_txnid(lock_request *const &request, const TXNID &txnid); |
||||
|
||||
// Report list of conflicts to lock wait callback.
|
||||
static void report_waits(GrowableArray<TXNID> *wait_conflicts, |
||||
void (*lock_wait_callback)(void *, TXNID, TXNID), |
||||
void *callback_arg); |
||||
void add_conflicts_to_waits(txnid_set *conflicts, |
||||
GrowableArray<TXNID> *wait_conflicts); |
||||
|
||||
void (*m_start_test_callback)(void); |
||||
void (*m_start_before_pending_test_callback)(void); |
||||
void (*m_retry_test_callback)(void); |
||||
|
||||
public: |
||||
std::function<void(TXNID, bool, const DBT *, const DBT *)> m_deadlock_cb; |
||||
|
||||
friend class lock_request_unit_test; |
||||
}; |
||||
// PORT: lock_request is not a POD anymore due to use of toku_external_cond_t
|
||||
// This is ok as the PODness is not really required: lock_request objects are
|
||||
// not moved in memory or anything.
|
||||
// ENSURE_POD(lock_request);
|
||||
|
||||
} /* namespace toku */ |
||||
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,559 @@ |
||||
/* -*- mode: C++; c-basic-offset: 4; indent-tabs-mode: nil -*- */ |
||||
// vim: ft=cpp:expandtab:ts=8:sw=4:softtabstop=4:
|
||||
#ident "$Id$" |
||||
/*======
|
||||
This file is part of PerconaFT. |
||||
|
||||
|
||||
Copyright (c) 2006, 2015, Percona and/or its affiliates. All rights reserved. |
||||
|
||||
PerconaFT is free software: you can redistribute it and/or modify |
||||
it under the terms of the GNU General Public License, version 2, |
||||
as published by the Free Software Foundation. |
||||
|
||||
PerconaFT is distributed in the hope that it will be useful, |
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
GNU General Public License for more details. |
||||
|
||||
You should have received a copy of the GNU General Public License |
||||
along with PerconaFT. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
---------------------------------------- |
||||
|
||||
PerconaFT is free software: you can redistribute it and/or modify |
||||
it under the terms of the GNU Affero General Public License, version 3, |
||||
as published by the Free Software Foundation. |
||||
|
||||
PerconaFT is distributed in the hope that it will be useful, |
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
GNU Affero General Public License for more details. |
||||
|
||||
You should have received a copy of the GNU Affero General Public License |
||||
along with PerconaFT. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
---------------------------------------- |
||||
|
||||
Licensed under the Apache License, Version 2.0 (the "License"); |
||||
you may not use this file except in compliance with the License. |
||||
You may obtain a copy of the License at |
||||
|
||||
http://www.apache.org/licenses/LICENSE-2.0
|
||||
|
||||
Unless required by applicable law or agreed to in writing, software |
||||
distributed under the License is distributed on an "AS IS" BASIS, |
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
||||
See the License for the specific language governing permissions and |
||||
======= */ |
||||
|
||||
#ident \ |
||||
"Copyright (c) 2006, 2015, Percona and/or its affiliates. All rights reserved." |
||||
|
||||
#pragma once |
||||
|
||||
#include <atomic> |
||||
|
||||
#include "../db.h" |
||||
#include "../ft/comparator.h" |
||||
#include "../portability/toku_external_pthread.h" |
||||
#include "../portability/toku_pthread.h" |
||||
#include "../portability/toku_time.h" |
||||
// PORT #include <ft/ft-ops.h> // just for DICTIONARY_ID..
|
||||
// PORT: ft-status for LTM_STATUS:
|
||||
#include "../ft/ft-status.h" |
||||
|
||||
struct DICTIONARY_ID { |
||||
uint64_t dictid; |
||||
}; |
||||
|
||||
#include "../util/omt.h" |
||||
#include "range_buffer.h" |
||||
#include "txnid_set.h" |
||||
#include "wfg.h" |
||||
|
||||
namespace toku { |
||||
|
||||
class locktree; |
||||
class locktree_manager; |
||||
class lock_request; |
||||
class concurrent_tree; |
||||
|
||||
typedef int (*lt_create_cb)(locktree *lt, void *extra); |
||||
typedef void (*lt_destroy_cb)(locktree *lt); |
||||
typedef void (*lt_escalate_cb)(TXNID txnid, const locktree *lt, |
||||
const range_buffer &buffer, void *extra); |
||||
|
||||
struct lt_counters { |
||||
uint64_t wait_count, wait_time; |
||||
uint64_t long_wait_count, long_wait_time; |
||||
uint64_t timeout_count; |
||||
|
||||
void add(const lt_counters &rhs) { |
||||
wait_count += rhs.wait_count; |
||||
wait_time += rhs.wait_time; |
||||
long_wait_count += rhs.long_wait_count; |
||||
long_wait_time += rhs.long_wait_time; |
||||
timeout_count += rhs.timeout_count; |
||||
} |
||||
}; |
||||
|
||||
// Lock request state for some locktree
|
||||
struct lt_lock_request_info { |
||||
omt<lock_request *> pending_lock_requests; |
||||
std::atomic_bool pending_is_empty; |
||||
toku_external_mutex_t mutex; |
||||
bool should_retry_lock_requests; |
||||
lt_counters counters; |
||||
std::atomic_ullong retry_want; |
||||
unsigned long long retry_done; |
||||
toku_mutex_t retry_mutex; |
||||
toku_cond_t retry_cv; |
||||
bool running_retry; |
||||
|
||||
void init(toku_external_mutex_factory_t mutex_factory); |
||||
void destroy(void); |
||||
}; |
||||
|
||||
// The locktree manager manages a set of locktrees, one for each open
|
||||
// dictionary. Locktrees are retrieved from the manager. When they are no
|
||||
// longer needed, they are be released by the user.
|
||||
class locktree_manager { |
||||
public: |
||||
// param: create_cb, called just after a locktree is first created.
|
||||
// destroy_cb, called just before a locktree is destroyed.
|
||||
// escalate_cb, called after a locktree is escalated (with extra
|
||||
// param)
|
||||
void create(lt_create_cb create_cb, lt_destroy_cb destroy_cb, |
||||
lt_escalate_cb escalate_cb, void *extra, |
||||
toku_external_mutex_factory_t mutex_factory_arg); |
||||
|
||||
void destroy(void); |
||||
|
||||
size_t get_max_lock_memory(void); |
||||
|
||||
int set_max_lock_memory(size_t max_lock_memory); |
||||
|
||||
// effect: Get a locktree from the manager. If a locktree exists with the
|
||||
// given
|
||||
// dict_id, it is referenced and then returned. If one did not exist,
|
||||
// it is created. It will use the comparator for comparing keys. The
|
||||
// on_create callback (passed to locktree_manager::create()) will be
|
||||
// called with the given extra parameter.
|
||||
locktree *get_lt(DICTIONARY_ID dict_id, const comparator &cmp, |
||||
void *on_create_extra); |
||||
|
||||
void reference_lt(locktree *lt); |
||||
|
||||
// effect: Releases one reference on a locktree. If the reference count
|
||||
// transitions
|
||||
// to zero, the on_destroy callback is called before it gets
|
||||
// destroyed.
|
||||
void release_lt(locktree *lt); |
||||
|
||||
void get_status(LTM_STATUS status); |
||||
|
||||
// effect: calls the iterate function on each pending lock request
|
||||
// note: holds the manager's mutex
|
||||
typedef int (*lock_request_iterate_callback)(DICTIONARY_ID dict_id, |
||||
TXNID txnid, const DBT *left_key, |
||||
const DBT *right_key, |
||||
TXNID blocking_txnid, |
||||
uint64_t start_time, |
||||
void *extra); |
||||
int iterate_pending_lock_requests(lock_request_iterate_callback cb, |
||||
void *extra); |
||||
|
||||
// effect: Determines if too many locks or too much memory is being used,
|
||||
// Runs escalation on the manager if so.
|
||||
// param: big_txn, if the current transaction is 'big' (has spilled rollback
|
||||
// logs) returns: 0 if there enough resources to create a new lock, or
|
||||
// TOKUDB_OUT_OF_LOCKS
|
||||
// if there are not enough resources and lock escalation failed to
|
||||
// free up enough resources for a new lock.
|
||||
int check_current_lock_constraints(bool big_txn); |
||||
|
||||
bool over_big_threshold(void); |
||||
|
||||
void note_mem_used(uint64_t mem_used); |
||||
|
||||
void note_mem_released(uint64_t mem_freed); |
||||
|
||||
bool out_of_locks(void) const; |
||||
|
||||
// Escalate all locktrees
|
||||
void escalate_all_locktrees(void); |
||||
|
||||
// Escalate a set of locktrees
|
||||
void escalate_locktrees(locktree **locktrees, int num_locktrees); |
||||
|
||||
// effect: calls the private function run_escalation(), only ok to
|
||||
// do for tests.
|
||||
// rationale: to get better stress test coverage, we want a way to
|
||||
// deterministicly trigger lock escalation.
|
||||
void run_escalation_for_test(void); |
||||
void run_escalation(void); |
||||
|
||||
// Add time t to the escalator's wait time statistics
|
||||
void add_escalator_wait_time(uint64_t t); |
||||
|
||||
void kill_waiter(void *extra); |
||||
|
||||
private: |
||||
static const uint64_t DEFAULT_MAX_LOCK_MEMORY = 64L * 1024 * 1024; |
||||
|
||||
// tracks the current number of locks and lock memory
|
||||
uint64_t m_max_lock_memory; |
||||
uint64_t m_current_lock_memory; |
||||
|
||||
struct lt_counters m_lt_counters; |
||||
|
||||
// the create and destroy callbacks for the locktrees
|
||||
lt_create_cb m_lt_create_callback; |
||||
lt_destroy_cb m_lt_destroy_callback; |
||||
lt_escalate_cb m_lt_escalate_callback; |
||||
void *m_lt_escalate_callback_extra; |
||||
|
||||
omt<locktree *> m_locktree_map; |
||||
|
||||
toku_external_mutex_factory_t mutex_factory; |
||||
|
||||
// the manager's mutex protects the locktree map
|
||||
toku_mutex_t m_mutex; |
||||
|
||||
void mutex_lock(void); |
||||
|
||||
void mutex_unlock(void); |
||||
|
||||
// Manage the set of open locktrees
|
||||
locktree *locktree_map_find(const DICTIONARY_ID &dict_id); |
||||
void locktree_map_put(locktree *lt); |
||||
void locktree_map_remove(locktree *lt); |
||||
|
||||
static int find_by_dict_id(locktree *const <, const DICTIONARY_ID &dict_id); |
||||
|
||||
void escalator_init(void); |
||||
void escalator_destroy(void); |
||||
|
||||
// statistics about lock escalation.
|
||||
toku_mutex_t m_escalation_mutex; |
||||
uint64_t m_escalation_count; |
||||
tokutime_t m_escalation_time; |
||||
uint64_t m_escalation_latest_result; |
||||
uint64_t m_wait_escalation_count; |
||||
uint64_t m_wait_escalation_time; |
||||
uint64_t m_long_wait_escalation_count; |
||||
uint64_t m_long_wait_escalation_time; |
||||
|
||||
// the escalator coordinates escalation on a set of locktrees for a bunch of
|
||||
// threads
|
||||
class locktree_escalator { |
||||
public: |
||||
void create(void); |
||||
void destroy(void); |
||||
void run(locktree_manager *mgr, void (*escalate_locktrees_fun)(void *extra), |
||||
void *extra); |
||||
|
||||
private: |
||||
toku_mutex_t m_escalator_mutex; |
||||
toku_cond_t m_escalator_done; |
||||
bool m_escalator_running; |
||||
}; |
||||
|
||||
locktree_escalator m_escalator; |
||||
|
||||
friend class manager_unit_test; |
||||
}; |
||||
|
||||
// A locktree represents the set of row locks owned by all transactions
|
||||
// over an open dictionary. Read and write ranges are represented as
|
||||
// a left and right key which are compared with the given comparator
|
||||
//
|
||||
// Locktrees are not created and destroyed by the user. Instead, they are
|
||||
// referenced and released using the locktree manager.
|
||||
//
|
||||
// A sample workflow looks like this:
|
||||
// - Create a manager.
|
||||
// - Get a locktree by dictionaroy id from the manager.
|
||||
// - Perform read/write lock acquision on the locktree, add references to
|
||||
// the locktree using the manager, release locks, release references, etc.
|
||||
// - ...
|
||||
// - Release the final reference to the locktree. It will be destroyed.
|
||||
// - Destroy the manager.
|
||||
class locktree { |
||||
public: |
||||
// effect: Creates a locktree
|
||||
void create(locktree_manager *mgr, DICTIONARY_ID dict_id, |
||||
const comparator &cmp, |
||||
toku_external_mutex_factory_t mutex_factory); |
||||
|
||||
void destroy(void); |
||||
|
||||
// For thread-safe, external reference counting
|
||||
void add_reference(void); |
||||
|
||||
// requires: the reference count is > 0
|
||||
// returns: the reference count, after decrementing it by one
|
||||
uint32_t release_reference(void); |
||||
|
||||
// returns: the current reference count
|
||||
uint32_t get_reference_count(void); |
||||
|
||||
// effect: Attempts to grant a read lock for the range of keys between
|
||||
// [left_key, right_key]. returns: If the lock cannot be granted, return
|
||||
// DB_LOCK_NOTGRANTED, and populate the
|
||||
// given conflicts set with the txnids that hold conflicting locks in
|
||||
// the range. If the locktree cannot create more locks, return
|
||||
// TOKUDB_OUT_OF_LOCKS.
|
||||
// note: Read locks cannot be shared between txnids, as one would expect.
|
||||
// This is for simplicity since read locks are rare in MySQL.
|
||||
int acquire_read_lock(TXNID txnid, const DBT *left_key, const DBT *right_key, |
||||
txnid_set *conflicts, bool big_txn); |
||||
|
||||
// effect: Attempts to grant a write lock for the range of keys between
|
||||
// [left_key, right_key]. returns: If the lock cannot be granted, return
|
||||
// DB_LOCK_NOTGRANTED, and populate the
|
||||
// given conflicts set with the txnids that hold conflicting locks in
|
||||
// the range. If the locktree cannot create more locks, return
|
||||
// TOKUDB_OUT_OF_LOCKS.
|
||||
int acquire_write_lock(TXNID txnid, const DBT *left_key, const DBT *right_key, |
||||
txnid_set *conflicts, bool big_txn); |
||||
|
||||
// effect: populate the conflicts set with the txnids that would preventing
|
||||
// the given txnid from getting a lock on [left_key, right_key]
|
||||
void get_conflicts(bool is_write_request, TXNID txnid, const DBT *left_key, |
||||
const DBT *right_key, txnid_set *conflicts); |
||||
|
||||
// effect: Release all of the lock ranges represented by the range buffer for
|
||||
// a txnid.
|
||||
void release_locks(TXNID txnid, const range_buffer *ranges, |
||||
bool all_trx_locks_hint = false); |
||||
|
||||
// effect: Runs escalation on this locktree
|
||||
void escalate(lt_escalate_cb after_escalate_callback, void *extra); |
||||
|
||||
// returns: The userdata associated with this locktree, or null if it has not
|
||||
// been set.
|
||||
void *get_userdata(void) const; |
||||
|
||||
void set_userdata(void *userdata); |
||||
|
||||
locktree_manager *get_manager(void) const; |
||||
|
||||
void set_comparator(const comparator &cmp); |
||||
|
||||
int compare(const locktree *lt) const; |
||||
|
||||
DICTIONARY_ID get_dict_id() const; |
||||
|
||||
// Private info struct for storing pending lock request state.
|
||||
// Only to be used by lock requests. We store it here as
|
||||
// something less opaque than usual to strike a tradeoff between
|
||||
// abstraction and code complexity. It is still fairly abstract
|
||||
// since the lock_request object is opaque
|
||||
struct lt_lock_request_info *get_lock_request_info(void); |
||||
|
||||
typedef void (*dump_callback)(void *cdata, const DBT *left, const DBT *right, |
||||
TXNID txnid, bool is_shared, |
||||
TxnidVector *owners); |
||||
void dump_locks(void *cdata, dump_callback cb); |
||||
|
||||
private: |
||||
locktree_manager *m_mgr; |
||||
DICTIONARY_ID m_dict_id; |
||||
uint32_t m_reference_count; |
||||
|
||||
// Since the memory referenced by this comparator is not owned by the
|
||||
// locktree, the user must guarantee it will outlive the locktree.
|
||||
//
|
||||
// The ydb API accomplishes this by opening an ft_handle in the on_create
|
||||
// callback, which will keep the underlying FT (and its descriptor) in memory
|
||||
// for as long as the handle is open. The ft_handle is stored opaquely in the
|
||||
// userdata pointer below. see locktree_manager::get_lt w/ on_create_extra
|
||||
comparator m_cmp; |
||||
|
||||
concurrent_tree *m_rangetree; |
||||
|
||||
void *m_userdata; |
||||
struct lt_lock_request_info m_lock_request_info; |
||||
|
||||
// psergey-todo:
|
||||
// Each transaction also keeps a list of ranges it has locked.
|
||||
// So, when a transaction is running in STO mode, two identical
|
||||
// lists are kept: the STO lock list and transaction's owned locks
|
||||
// list. Why can't we do with just one list?
|
||||
|
||||
// The following fields and members prefixed with "sto_" are for
|
||||
// the single txnid optimization, intended to speed up the case
|
||||
// when only one transaction is using the locktree. If we know
|
||||
// the locktree has only one transaction, then acquiring locks
|
||||
// takes O(1) work and releasing all locks takes O(1) work.
|
||||
//
|
||||
// How do we know that the locktree only has a single txnid?
|
||||
// What do we do if it does?
|
||||
//
|
||||
// When a txn with txnid T requests a lock:
|
||||
// - If the tree is empty, the optimization is possible. Set the single
|
||||
// txnid to T, and insert the lock range into the buffer.
|
||||
// - If the tree is not empty, check if the single txnid is T. If so,
|
||||
// append the lock range to the buffer. Otherwise, migrate all of
|
||||
// the locks in the buffer into the rangetree on behalf of txnid T,
|
||||
// and invalid the single txnid.
|
||||
//
|
||||
// When a txn with txnid T releases its locks:
|
||||
// - If the single txnid is valid, it must be for T. Destroy the buffer.
|
||||
// - If it's not valid, release locks the normal way in the rangetree.
|
||||
//
|
||||
// To carry out the optimization we need to record a single txnid
|
||||
// and a range buffer for each locktree, each protected by the root
|
||||
// lock of the locktree's rangetree. The root lock for a rangetree
|
||||
// is grabbed by preparing a locked keyrange on the rangetree.
|
||||
TXNID m_sto_txnid; |
||||
range_buffer m_sto_buffer; |
||||
|
||||
// The single txnid optimization speeds up the case when only one
|
||||
// transaction is using the locktree. But it has the potential to
|
||||
// hurt the case when more than one txnid exists.
|
||||
//
|
||||
// There are two things we need to do to make the optimization only
|
||||
// optimize the case we care about, and not hurt the general case.
|
||||
//
|
||||
// Bound the worst-case latency for lock migration when the
|
||||
// optimization stops working:
|
||||
// - Idea: Stop the optimization and migrate immediate if we notice
|
||||
// the single txnid has takes many locks in the range buffer.
|
||||
// - Implementation: Enforce a max size on the single txnid range buffer.
|
||||
// - Analysis: Choosing the perfect max value, M, is difficult to do
|
||||
// without some feedback from the field. Intuition tells us that M should
|
||||
// not be so small that the optimization is worthless, and it should not
|
||||
// be so big that it's unreasonable to have to wait behind a thread doing
|
||||
// the work of converting M buffer locks into rangetree locks.
|
||||
//
|
||||
// Prevent concurrent-transaction workloads from trying the optimization
|
||||
// in vain:
|
||||
// - Idea: Don't even bother trying the optimization if we think the
|
||||
// system is in a concurrent-transaction state.
|
||||
// - Implementation: Do something even simpler than detecting whether the
|
||||
// system is in a concurent-transaction state. Just keep a "score" value
|
||||
// and some threshold. If at any time the locktree is eligible for the
|
||||
// optimization, only do it if the score is at this threshold. When you
|
||||
// actually do the optimization but someone has to migrate locks in the buffer
|
||||
// (expensive), then reset the score back to zero. Each time a txn
|
||||
// releases locks, the score is incremented by 1.
|
||||
// - Analysis: If you let the threshold be "C", then at most 1 / C txns will
|
||||
// do the optimization in a concurrent-transaction system. Similarly, it
|
||||
// takes at most C txns to start using the single txnid optimzation, which
|
||||
// is good when the system transitions from multithreaded to single threaded.
|
||||
//
|
||||
// STO_BUFFER_MAX_SIZE:
|
||||
//
|
||||
// We choose the max value to be 1 million since most transactions are smaller
|
||||
// than 1 million and we can create a rangetree of 1 million elements in
|
||||
// less than a second. So we can be pretty confident that this threshold
|
||||
// enables the optimization almost always, and prevents super pathological
|
||||
// latency issues for the first lock taken by a second thread.
|
||||
//
|
||||
// STO_SCORE_THRESHOLD:
|
||||
//
|
||||
// A simple first guess at a good value for the score threshold is 100.
|
||||
// By our analysis, we'd end up doing the optimization in vain for
|
||||
// around 1% of all transactions, which seems reasonable. Further,
|
||||
// if the system goes single threaded, it ought to be pretty quick
|
||||
// for 100 transactions to go by, so we won't have to wait long before
|
||||
// we start doing the single txind optimzation again.
|
||||
static const int STO_BUFFER_MAX_SIZE = 50 * 1024; |
||||
static const int STO_SCORE_THRESHOLD = 100; |
||||
int m_sto_score; |
||||
|
||||
// statistics about time spent ending the STO early
|
||||
uint64_t m_sto_end_early_count; |
||||
tokutime_t m_sto_end_early_time; |
||||
|
||||
// effect: begins the single txnid optimizaiton, setting m_sto_txnid
|
||||
// to the given txnid.
|
||||
// requires: m_sto_txnid is invalid
|
||||
void sto_begin(TXNID txnid); |
||||
|
||||
// effect: append a range to the sto buffer
|
||||
// requires: m_sto_txnid is valid
|
||||
void sto_append(const DBT *left_key, const DBT *right_key, |
||||
bool is_write_request); |
||||
|
||||
// effect: ends the single txnid optimization, releaseing any memory
|
||||
// stored in the sto buffer, notifying the tracker, and
|
||||
// invalidating m_sto_txnid.
|
||||
// requires: m_sto_txnid is valid
|
||||
void sto_end(void); |
||||
|
||||
// params: prepared_lkr is a void * to a prepared locked keyrange. see below.
|
||||
// effect: ends the single txnid optimization early, migrating buffer locks
|
||||
// into the rangetree, calling sto_end(), and then setting the
|
||||
// sto_score back to zero.
|
||||
// requires: m_sto_txnid is valid
|
||||
void sto_end_early(void *prepared_lkr); |
||||
void sto_end_early_no_accounting(void *prepared_lkr); |
||||
|
||||
// params: prepared_lkr is a void * to a prepared locked keyrange. we can't
|
||||
// use
|
||||
// the real type because the compiler won't allow us to forward
|
||||
// declare concurrent_tree::locked_keyrange without including
|
||||
// concurrent_tree.h, which we cannot do here because it is a template
|
||||
// implementation.
|
||||
// requires: the prepared locked keyrange is for the locktree's rangetree
|
||||
// requires: m_sto_txnid is valid
|
||||
// effect: migrates each lock in the single txnid buffer into the locktree's
|
||||
// rangetree, notifying the memory tracker as necessary.
|
||||
void sto_migrate_buffer_ranges_to_tree(void *prepared_lkr); |
||||
|
||||
// effect: If m_sto_txnid is valid, then release the txnid's locks
|
||||
// by ending the optimization.
|
||||
// requires: If m_sto_txnid is valid, it is equal to the given txnid
|
||||
// returns: True if locks were released for this txnid
|
||||
bool sto_try_release(TXNID txnid); |
||||
|
||||
// params: prepared_lkr is a void * to a prepared locked keyrange. see above.
|
||||
// requires: the prepared locked keyrange is for the locktree's rangetree
|
||||
// effect: If m_sto_txnid is valid and equal to the given txnid, then
|
||||
// append a range onto the buffer. Otherwise, if m_sto_txnid is valid
|
||||
// but not equal to this txnid, then migrate the buffer's locks
|
||||
// into the rangetree and end the optimization, setting the score
|
||||
// back to zero.
|
||||
// returns: true if the lock was acquired for this txnid
|
||||
bool sto_try_acquire(void *prepared_lkr, TXNID txnid, const DBT *left_key, |
||||
const DBT *right_key, bool is_write_request); |
||||
|
||||
// Effect:
|
||||
// Provides a hook for a helgrind suppression.
|
||||
// Returns:
|
||||
// true if m_sto_txnid is not TXNID_NONE
|
||||
bool sto_txnid_is_valid_unsafe(void) const; |
||||
|
||||
// Effect:
|
||||
// Provides a hook for a helgrind suppression.
|
||||
// Returns:
|
||||
// m_sto_score
|
||||
int sto_get_score_unsafe(void) const; |
||||
|
||||
void remove_overlapping_locks_for_txnid(TXNID txnid, const DBT *left_key, |
||||
const DBT *right_key); |
||||
|
||||
int acquire_lock_consolidated(void *prepared_lkr, TXNID txnid, |
||||
const DBT *left_key, const DBT *right_key, |
||||
bool is_write_request, txnid_set *conflicts); |
||||
|
||||
int acquire_lock(bool is_write_request, TXNID txnid, const DBT *left_key, |
||||
const DBT *right_key, txnid_set *conflicts); |
||||
|
||||
int try_acquire_lock(bool is_write_request, TXNID txnid, const DBT *left_key, |
||||
const DBT *right_key, txnid_set *conflicts, |
||||
bool big_txn); |
||||
|
||||
friend class locktree_unit_test; |
||||
friend class manager_unit_test; |
||||
friend class lock_request_unit_test; |
||||
|
||||
// engine status reaches into the locktree to read some stats
|
||||
friend void locktree_manager::get_status(LTM_STATUS status); |
||||
}; |
||||
|
||||
} /* namespace toku */ |
||||
@ -0,0 +1,526 @@ |
||||
/* -*- mode: C++; c-basic-offset: 4; indent-tabs-mode: nil -*- */ |
||||
// vim: ft=cpp:expandtab:ts=8:sw=4:softtabstop=4:
|
||||
#ifndef ROCKSDB_LITE |
||||
#ifndef OS_WIN |
||||
#ident "$Id$" |
||||
/*======
|
||||
This file is part of PerconaFT. |
||||
|
||||
|
||||
Copyright (c) 2006, 2015, Percona and/or its affiliates. All rights reserved. |
||||
|
||||
PerconaFT is free software: you can redistribute it and/or modify |
||||
it under the terms of the GNU General Public License, version 2, |
||||
as published by the Free Software Foundation. |
||||
|
||||
PerconaFT is distributed in the hope that it will be useful, |
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
GNU General Public License for more details. |
||||
|
||||
You should have received a copy of the GNU General Public License |
||||
along with PerconaFT. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
---------------------------------------- |
||||
|
||||
PerconaFT is free software: you can redistribute it and/or modify |
||||
it under the terms of the GNU Affero General Public License, version 3, |
||||
as published by the Free Software Foundation. |
||||
|
||||
PerconaFT is distributed in the hope that it will be useful, |
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
GNU Affero General Public License for more details. |
||||
|
||||
You should have received a copy of the GNU Affero General Public License |
||||
along with PerconaFT. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
---------------------------------------- |
||||
|
||||
Licensed under the Apache License, Version 2.0 (the "License"); |
||||
you may not use this file except in compliance with the License. |
||||
You may obtain a copy of the License at |
||||
|
||||
http://www.apache.org/licenses/LICENSE-2.0
|
||||
|
||||
Unless required by applicable law or agreed to in writing, software |
||||
distributed under the License is distributed on an "AS IS" BASIS, |
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
||||
See the License for the specific language governing permissions and |
||||
======= */ |
||||
|
||||
#ident \ |
||||
"Copyright (c) 2006, 2015, Percona and/or its affiliates. All rights reserved." |
||||
|
||||
#include <stdlib.h> |
||||
#include <string.h> |
||||
|
||||
#include "../portability/toku_pthread.h" |
||||
#include "../util/status.h" |
||||
#include "lock_request.h" |
||||
#include "locktree.h" |
||||
|
||||
namespace toku { |
||||
|
||||
void locktree_manager::create(lt_create_cb create_cb, lt_destroy_cb destroy_cb, |
||||
lt_escalate_cb escalate_cb, void *escalate_extra, |
||||
toku_external_mutex_factory_t mutex_factory_arg) { |
||||
mutex_factory = mutex_factory_arg; |
||||
m_max_lock_memory = DEFAULT_MAX_LOCK_MEMORY; |
||||
m_current_lock_memory = 0; |
||||
|
||||
m_locktree_map.create(); |
||||
m_lt_create_callback = create_cb; |
||||
m_lt_destroy_callback = destroy_cb; |
||||
m_lt_escalate_callback = escalate_cb; |
||||
m_lt_escalate_callback_extra = escalate_extra; |
||||
ZERO_STRUCT(m_mutex); |
||||
toku_mutex_init(manager_mutex_key, &m_mutex, nullptr); |
||||
|
||||
ZERO_STRUCT(m_lt_counters); |
||||
|
||||
escalator_init(); |
||||
} |
||||
|
||||
void locktree_manager::destroy(void) { |
||||
escalator_destroy(); |
||||
invariant(m_current_lock_memory == 0); |
||||
invariant(m_locktree_map.size() == 0); |
||||
m_locktree_map.destroy(); |
||||
toku_mutex_destroy(&m_mutex); |
||||
} |
||||
|
||||
void locktree_manager::mutex_lock(void) { toku_mutex_lock(&m_mutex); } |
||||
|
||||
void locktree_manager::mutex_unlock(void) { toku_mutex_unlock(&m_mutex); } |
||||
|
||||
size_t locktree_manager::get_max_lock_memory(void) { return m_max_lock_memory; } |
||||
|
||||
int locktree_manager::set_max_lock_memory(size_t max_lock_memory) { |
||||
int r = 0; |
||||
mutex_lock(); |
||||
if (max_lock_memory < m_current_lock_memory) { |
||||
r = EDOM; |
||||
} else { |
||||
m_max_lock_memory = max_lock_memory; |
||||
} |
||||
mutex_unlock(); |
||||
return r; |
||||
} |
||||
|
||||
int locktree_manager::find_by_dict_id(locktree *const <, |
||||
const DICTIONARY_ID &dict_id) { |
||||
if (lt->get_dict_id().dictid < dict_id.dictid) { |
||||
return -1; |
||||
} else if (lt->get_dict_id().dictid == dict_id.dictid) { |
||||
return 0; |
||||
} else { |
||||
return 1; |
||||
} |
||||
} |
||||
|
||||
locktree *locktree_manager::locktree_map_find(const DICTIONARY_ID &dict_id) { |
||||
locktree *lt; |
||||
int r = m_locktree_map.find_zero<DICTIONARY_ID, find_by_dict_id>(dict_id, <, |
||||
nullptr); |
||||
return r == 0 ? lt : nullptr; |
||||
} |
||||
|
||||
void locktree_manager::locktree_map_put(locktree *lt) { |
||||
int r = m_locktree_map.insert<DICTIONARY_ID, find_by_dict_id>( |
||||
lt, lt->get_dict_id(), nullptr); |
||||
invariant_zero(r); |
||||
} |
||||
|
||||
void locktree_manager::locktree_map_remove(locktree *lt) { |
||||
uint32_t idx; |
||||
locktree *found_lt; |
||||
int r = m_locktree_map.find_zero<DICTIONARY_ID, find_by_dict_id>( |
||||
lt->get_dict_id(), &found_lt, &idx); |
||||
invariant_zero(r); |
||||
invariant(found_lt == lt); |
||||
r = m_locktree_map.delete_at(idx); |
||||
invariant_zero(r); |
||||
} |
||||
|
||||
locktree *locktree_manager::get_lt(DICTIONARY_ID dict_id, const comparator &cmp, |
||||
void *on_create_extra) { |
||||
// hold the mutex around searching and maybe
|
||||
// inserting into the locktree map
|
||||
mutex_lock(); |
||||
|
||||
locktree *lt = locktree_map_find(dict_id); |
||||
if (lt == nullptr) { |
||||
XCALLOC(lt); |
||||
lt->create(this, dict_id, cmp, mutex_factory); |
||||
|
||||
// new locktree created - call the on_create callback
|
||||
// and put it in the locktree map
|
||||
if (m_lt_create_callback) { |
||||
int r = m_lt_create_callback(lt, on_create_extra); |
||||
if (r != 0) { |
||||
lt->release_reference(); |
||||
lt->destroy(); |
||||
toku_free(lt); |
||||
lt = nullptr; |
||||
} |
||||
} |
||||
if (lt) { |
||||
locktree_map_put(lt); |
||||
} |
||||
} else { |
||||
reference_lt(lt); |
||||
} |
||||
|
||||
mutex_unlock(); |
||||
|
||||
return lt; |
||||
} |
||||
|
||||
void locktree_manager::reference_lt(locktree *lt) { |
||||
// increment using a sync fetch and add.
|
||||
// the caller guarantees that the lt won't be
|
||||
// destroyed while we increment the count here.
|
||||
//
|
||||
// the caller can do this by already having an lt
|
||||
// reference or by holding the manager mutex.
|
||||
//
|
||||
// if the manager's mutex is held, it is ok for the
|
||||
// reference count to transition from 0 to 1 (no race),
|
||||
// since we're serialized with other opens and closes.
|
||||
lt->add_reference(); |
||||
} |
||||
|
||||
void locktree_manager::release_lt(locktree *lt) { |
||||
bool do_destroy = false; |
||||
DICTIONARY_ID dict_id = lt->get_dict_id(); |
||||
|
||||
// Release a reference on the locktree. If the count transitions to zero,
|
||||
// then we *may* need to do the cleanup.
|
||||
//
|
||||
// Grab the manager's mutex and look for a locktree with this locktree's
|
||||
// dictionary id. Since dictionary id's never get reused, any locktree
|
||||
// found must be the one we just released a reference on.
|
||||
//
|
||||
// At least two things could have happened since we got the mutex:
|
||||
// - Another thread gets a locktree with the same dict_id, increments
|
||||
// the reference count. In this case, we shouldn't destroy it.
|
||||
// - Another thread gets a locktree with the same dict_id and then
|
||||
// releases it quickly, transitioning the reference count from zero to
|
||||
// one and back to zero. In this case, only one of us should destroy it.
|
||||
// It doesn't matter which. We originally missed this case, see #5776.
|
||||
//
|
||||
// After 5776, the high level rule for release is described below.
|
||||
//
|
||||
// If a thread releases a locktree and notices the reference count transition
|
||||
// to zero, then that thread must immediately:
|
||||
// - assume the locktree object is invalid
|
||||
// - grab the manager's mutex
|
||||
// - search the locktree map for a locktree with the same dict_id and remove
|
||||
// it, if it exists. the destroy may be deferred.
|
||||
// - release the manager's mutex
|
||||
//
|
||||
// This way, if many threads transition the same locktree's reference count
|
||||
// from 1 to zero and wait behind the manager's mutex, only one of them will
|
||||
// do the actual destroy and the others will happily do nothing.
|
||||
uint32_t refs = lt->release_reference(); |
||||
if (refs == 0) { |
||||
mutex_lock(); |
||||
// lt may not have already been destroyed, so look it up.
|
||||
locktree *find_lt = locktree_map_find(dict_id); |
||||
if (find_lt != nullptr) { |
||||
// A locktree is still in the map with that dict_id, so it must be
|
||||
// equal to lt. This is true because dictionary ids are never reused.
|
||||
// If the reference count is zero, it's our responsibility to remove
|
||||
// it and do the destroy. Otherwise, someone still wants it.
|
||||
// If the locktree is still valid then check if it should be deleted.
|
||||
if (find_lt == lt) { |
||||
if (lt->get_reference_count() == 0) { |
||||
locktree_map_remove(lt); |
||||
do_destroy = true; |
||||
} |
||||
m_lt_counters.add(lt->get_lock_request_info()->counters); |
||||
} |
||||
} |
||||
mutex_unlock(); |
||||
} |
||||
|
||||
// if necessary, do the destroy without holding the mutex
|
||||
if (do_destroy) { |
||||
if (m_lt_destroy_callback) { |
||||
m_lt_destroy_callback(lt); |
||||
} |
||||
lt->destroy(); |
||||
toku_free(lt); |
||||
} |
||||
} |
||||
|
||||
void locktree_manager::run_escalation(void) { |
||||
struct escalation_fn { |
||||
static void run(void *extra) { |
||||
locktree_manager *mgr = (locktree_manager *)extra; |
||||
mgr->escalate_all_locktrees(); |
||||
}; |
||||
}; |
||||
m_escalator.run(this, escalation_fn::run, this); |
||||
} |
||||
|
||||
// test-only version of lock escalation
|
||||
void locktree_manager::run_escalation_for_test(void) { run_escalation(); } |
||||
|
||||
void locktree_manager::escalate_all_locktrees(void) { |
||||
uint64_t t0 = toku_current_time_microsec(); |
||||
|
||||
// get all locktrees
|
||||
mutex_lock(); |
||||
int num_locktrees = m_locktree_map.size(); |
||||
locktree **locktrees = new locktree *[num_locktrees]; |
||||
for (int i = 0; i < num_locktrees; i++) { |
||||
int r = m_locktree_map.fetch(i, &locktrees[i]); |
||||
invariant_zero(r); |
||||
reference_lt(locktrees[i]); |
||||
} |
||||
mutex_unlock(); |
||||
|
||||
// escalate them
|
||||
escalate_locktrees(locktrees, num_locktrees); |
||||
|
||||
delete[] locktrees; |
||||
|
||||
uint64_t t1 = toku_current_time_microsec(); |
||||
add_escalator_wait_time(t1 - t0); |
||||
} |
||||
|
||||
void locktree_manager::note_mem_used(uint64_t mem_used) { |
||||
(void)toku_sync_fetch_and_add(&m_current_lock_memory, mem_used); |
||||
} |
||||
|
||||
void locktree_manager::note_mem_released(uint64_t mem_released) { |
||||
uint64_t old_mem_used = |
||||
toku_sync_fetch_and_sub(&m_current_lock_memory, mem_released); |
||||
invariant(old_mem_used >= mem_released); |
||||
} |
||||
|
||||
bool locktree_manager::out_of_locks(void) const { |
||||
return m_current_lock_memory >= m_max_lock_memory; |
||||
} |
||||
|
||||
bool locktree_manager::over_big_threshold(void) { |
||||
return m_current_lock_memory >= m_max_lock_memory / 2; |
||||
} |
||||
|
||||
int locktree_manager::iterate_pending_lock_requests( |
||||
lock_request_iterate_callback callback, void *extra) { |
||||
mutex_lock(); |
||||
int r = 0; |
||||
uint32_t num_locktrees = m_locktree_map.size(); |
||||
for (uint32_t i = 0; i < num_locktrees && r == 0; i++) { |
||||
locktree *lt; |
||||
r = m_locktree_map.fetch(i, <); |
||||
invariant_zero(r); |
||||
if (r == EINVAL) // Shouldn't happen, avoid compiler warning
|
||||
continue; |
||||
|
||||
struct lt_lock_request_info *info = lt->get_lock_request_info(); |
||||
toku_external_mutex_lock(&info->mutex); |
||||
|
||||
uint32_t num_requests = info->pending_lock_requests.size(); |
||||
for (uint32_t k = 0; k < num_requests && r == 0; k++) { |
||||
lock_request *req; |
||||
r = info->pending_lock_requests.fetch(k, &req); |
||||
invariant_zero(r); |
||||
if (r == EINVAL) /* Shouldn't happen, avoid compiler warning */ |
||||
continue; |
||||
r = callback(lt->get_dict_id(), req->get_txnid(), req->get_left_key(), |
||||
req->get_right_key(), req->get_conflicting_txnid(), |
||||
req->get_start_time(), extra); |
||||
} |
||||
|
||||
toku_external_mutex_unlock(&info->mutex); |
||||
} |
||||
mutex_unlock(); |
||||
return r; |
||||
} |
||||
|
||||
int locktree_manager::check_current_lock_constraints(bool big_txn) { |
||||
int r = 0; |
||||
if (big_txn && over_big_threshold()) { |
||||
run_escalation(); |
||||
if (over_big_threshold()) { |
||||
r = TOKUDB_OUT_OF_LOCKS; |
||||
} |
||||
} |
||||
if (r == 0 && out_of_locks()) { |
||||
run_escalation(); |
||||
if (out_of_locks()) { |
||||
// return an error if we're still out of locks after escalation.
|
||||
r = TOKUDB_OUT_OF_LOCKS; |
||||
} |
||||
} |
||||
return r; |
||||
} |
||||
|
||||
void locktree_manager::escalator_init(void) { |
||||
ZERO_STRUCT(m_escalation_mutex); |
||||
toku_mutex_init(manager_escalation_mutex_key, &m_escalation_mutex, nullptr); |
||||
m_escalation_count = 0; |
||||
m_escalation_time = 0; |
||||
m_wait_escalation_count = 0; |
||||
m_wait_escalation_time = 0; |
||||
m_long_wait_escalation_count = 0; |
||||
m_long_wait_escalation_time = 0; |
||||
m_escalation_latest_result = 0; |
||||
m_escalator.create(); |
||||
} |
||||
|
||||
void locktree_manager::escalator_destroy(void) { |
||||
m_escalator.destroy(); |
||||
toku_mutex_destroy(&m_escalation_mutex); |
||||
} |
||||
|
||||
void locktree_manager::add_escalator_wait_time(uint64_t t) { |
||||
toku_mutex_lock(&m_escalation_mutex); |
||||
m_wait_escalation_count += 1; |
||||
m_wait_escalation_time += t; |
||||
if (t >= 1000000) { |
||||
m_long_wait_escalation_count += 1; |
||||
m_long_wait_escalation_time += t; |
||||
} |
||||
toku_mutex_unlock(&m_escalation_mutex); |
||||
} |
||||
|
||||
void locktree_manager::escalate_locktrees(locktree **locktrees, |
||||
int num_locktrees) { |
||||
// there are too many row locks in the system and we need to tidy up.
|
||||
//
|
||||
// a simple implementation of escalation does not attempt
|
||||
// to reduce the memory foot print of each txn's range buffer.
|
||||
// doing so would require some layering hackery (or a callback)
|
||||
// and more complicated locking. for now, just escalate each
|
||||
// locktree individually, in-place.
|
||||
tokutime_t t0 = toku_time_now(); |
||||
for (int i = 0; i < num_locktrees; i++) { |
||||
locktrees[i]->escalate(m_lt_escalate_callback, |
||||
m_lt_escalate_callback_extra); |
||||
release_lt(locktrees[i]); |
||||
} |
||||
tokutime_t t1 = toku_time_now(); |
||||
|
||||
toku_mutex_lock(&m_escalation_mutex); |
||||
m_escalation_count++; |
||||
m_escalation_time += (t1 - t0); |
||||
m_escalation_latest_result = m_current_lock_memory; |
||||
toku_mutex_unlock(&m_escalation_mutex); |
||||
} |
||||
|
||||
struct escalate_args { |
||||
locktree_manager *mgr; |
||||
locktree **locktrees; |
||||
int num_locktrees; |
||||
}; |
||||
|
||||
void locktree_manager::locktree_escalator::create(void) { |
||||
ZERO_STRUCT(m_escalator_mutex); |
||||
toku_mutex_init(manager_escalator_mutex_key, &m_escalator_mutex, nullptr); |
||||
toku_cond_init(manager_m_escalator_done_key, &m_escalator_done, nullptr); |
||||
m_escalator_running = false; |
||||
} |
||||
|
||||
void locktree_manager::locktree_escalator::destroy(void) { |
||||
toku_cond_destroy(&m_escalator_done); |
||||
toku_mutex_destroy(&m_escalator_mutex); |
||||
} |
||||
|
||||
void locktree_manager::locktree_escalator::run( |
||||
locktree_manager *mgr, void (*escalate_locktrees_fun)(void *extra), |
||||
void *extra) { |
||||
uint64_t t0 = toku_current_time_microsec(); |
||||
toku_mutex_lock(&m_escalator_mutex); |
||||
if (!m_escalator_running) { |
||||
// run escalation on this thread
|
||||
m_escalator_running = true; |
||||
toku_mutex_unlock(&m_escalator_mutex); |
||||
escalate_locktrees_fun(extra); |
||||
toku_mutex_lock(&m_escalator_mutex); |
||||
m_escalator_running = false; |
||||
toku_cond_broadcast(&m_escalator_done); |
||||
} else { |
||||
toku_cond_wait(&m_escalator_done, &m_escalator_mutex); |
||||
} |
||||
toku_mutex_unlock(&m_escalator_mutex); |
||||
uint64_t t1 = toku_current_time_microsec(); |
||||
mgr->add_escalator_wait_time(t1 - t0); |
||||
} |
||||
|
||||
void locktree_manager::get_status(LTM_STATUS statp) { |
||||
ltm_status.init(); |
||||
LTM_STATUS_VAL(LTM_SIZE_CURRENT) = m_current_lock_memory; |
||||
LTM_STATUS_VAL(LTM_SIZE_LIMIT) = m_max_lock_memory; |
||||
LTM_STATUS_VAL(LTM_ESCALATION_COUNT) = m_escalation_count; |
||||
LTM_STATUS_VAL(LTM_ESCALATION_TIME) = m_escalation_time; |
||||
LTM_STATUS_VAL(LTM_ESCALATION_LATEST_RESULT) = m_escalation_latest_result; |
||||
LTM_STATUS_VAL(LTM_WAIT_ESCALATION_COUNT) = m_wait_escalation_count; |
||||
LTM_STATUS_VAL(LTM_WAIT_ESCALATION_TIME) = m_wait_escalation_time; |
||||
LTM_STATUS_VAL(LTM_LONG_WAIT_ESCALATION_COUNT) = m_long_wait_escalation_count; |
||||
LTM_STATUS_VAL(LTM_LONG_WAIT_ESCALATION_TIME) = m_long_wait_escalation_time; |
||||
|
||||
uint64_t lock_requests_pending = 0; |
||||
uint64_t sto_num_eligible = 0; |
||||
uint64_t sto_end_early_count = 0; |
||||
tokutime_t sto_end_early_time = 0; |
||||
uint32_t num_locktrees = 0; |
||||
struct lt_counters lt_counters; |
||||
ZERO_STRUCT(lt_counters); // PORT: instead of ={}.
|
||||
|
||||
if (toku_mutex_trylock(&m_mutex) == 0) { |
||||
lt_counters = m_lt_counters; |
||||
num_locktrees = m_locktree_map.size(); |
||||
for (uint32_t i = 0; i < num_locktrees; i++) { |
||||
locktree *lt; |
||||
int r = m_locktree_map.fetch(i, <); |
||||
invariant_zero(r); |
||||
if (r == EINVAL) // Shouldn't happen, avoid compiler warning
|
||||
continue; |
||||
if (toku_external_mutex_trylock(<->m_lock_request_info.mutex) == 0) { |
||||
lock_requests_pending += |
||||
lt->m_lock_request_info.pending_lock_requests.size(); |
||||
lt_counters.add(lt->get_lock_request_info()->counters); |
||||
toku_external_mutex_unlock(<->m_lock_request_info.mutex); |
||||
} |
||||
sto_num_eligible += lt->sto_txnid_is_valid_unsafe() ? 1 : 0; |
||||
sto_end_early_count += lt->m_sto_end_early_count; |
||||
sto_end_early_time += lt->m_sto_end_early_time; |
||||
} |
||||
mutex_unlock(); |
||||
} |
||||
|
||||
LTM_STATUS_VAL(LTM_NUM_LOCKTREES) = num_locktrees; |
||||
LTM_STATUS_VAL(LTM_LOCK_REQUESTS_PENDING) = lock_requests_pending; |
||||
LTM_STATUS_VAL(LTM_STO_NUM_ELIGIBLE) = sto_num_eligible; |
||||
LTM_STATUS_VAL(LTM_STO_END_EARLY_COUNT) = sto_end_early_count; |
||||
LTM_STATUS_VAL(LTM_STO_END_EARLY_TIME) = sto_end_early_time; |
||||
LTM_STATUS_VAL(LTM_WAIT_COUNT) = lt_counters.wait_count; |
||||
LTM_STATUS_VAL(LTM_WAIT_TIME) = lt_counters.wait_time; |
||||
LTM_STATUS_VAL(LTM_LONG_WAIT_COUNT) = lt_counters.long_wait_count; |
||||
LTM_STATUS_VAL(LTM_LONG_WAIT_TIME) = lt_counters.long_wait_time; |
||||
LTM_STATUS_VAL(LTM_TIMEOUT_COUNT) = lt_counters.timeout_count; |
||||
*statp = ltm_status; |
||||
} |
||||
|
||||
void locktree_manager::kill_waiter(void *extra) { |
||||
mutex_lock(); |
||||
int r = 0; |
||||
uint32_t num_locktrees = m_locktree_map.size(); |
||||
for (uint32_t i = 0; i < num_locktrees; i++) { |
||||
locktree *lt; |
||||
r = m_locktree_map.fetch(i, <); |
||||
invariant_zero(r); |
||||
if (r) continue; // Get rid of "may be used uninitialized" warning
|
||||
lock_request::kill_waiter(lt, extra); |
||||
} |
||||
mutex_unlock(); |
||||
} |
||||
|
||||
} /* namespace toku */ |
||||
#endif // OS_WIN
|
||||
#endif // ROCKSDB_LITE
|
||||
@ -0,0 +1,264 @@ |
||||
/* -*- mode: C++; c-basic-offset: 4; indent-tabs-mode: nil -*- */ |
||||
// vim: ft=cpp:expandtab:ts=8:sw=4:softtabstop=4:
|
||||
#ifndef ROCKSDB_LITE |
||||
#ifndef OS_WIN |
||||
#ident "$Id$" |
||||
/*======
|
||||
This file is part of PerconaFT. |
||||
|
||||
|
||||
Copyright (c) 2006, 2015, Percona and/or its affiliates. All rights reserved. |
||||
|
||||
PerconaFT is free software: you can redistribute it and/or modify |
||||
it under the terms of the GNU General Public License, version 2, |
||||
as published by the Free Software Foundation. |
||||
|
||||
PerconaFT is distributed in the hope that it will be useful, |
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
GNU General Public License for more details. |
||||
|
||||
You should have received a copy of the GNU General Public License |
||||
along with PerconaFT. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
---------------------------------------- |
||||
|
||||
PerconaFT is free software: you can redistribute it and/or modify |
||||
it under the terms of the GNU Affero General Public License, version 3, |
||||
as published by the Free Software Foundation. |
||||
|
||||
PerconaFT is distributed in the hope that it will be useful, |
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
GNU Affero General Public License for more details. |
||||
|
||||
You should have received a copy of the GNU Affero General Public License |
||||
along with PerconaFT. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
---------------------------------------- |
||||
|
||||
Licensed under the Apache License, Version 2.0 (the "License"); |
||||
you may not use this file except in compliance with the License. |
||||
You may obtain a copy of the License at |
||||
|
||||
http://www.apache.org/licenses/LICENSE-2.0
|
||||
|
||||
Unless required by applicable law or agreed to in writing, software |
||||
distributed under the License is distributed on an "AS IS" BASIS, |
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
||||
See the License for the specific language governing permissions and |
||||
======= */ |
||||
|
||||
#ident \ |
||||
"Copyright (c) 2006, 2015, Percona and/or its affiliates. All rights reserved." |
||||
|
||||
#include "range_buffer.h" |
||||
|
||||
#include <string.h> |
||||
|
||||
#include "../portability/memory.h" |
||||
#include "../util/dbt.h" |
||||
|
||||
namespace toku { |
||||
|
||||
bool range_buffer::record_header::left_is_infinite(void) const { |
||||
return left_neg_inf || left_pos_inf; |
||||
} |
||||
|
||||
bool range_buffer::record_header::right_is_infinite(void) const { |
||||
return right_neg_inf || right_pos_inf; |
||||
} |
||||
|
||||
void range_buffer::record_header::init(const DBT *left_key, |
||||
const DBT *right_key, |
||||
bool is_exclusive) { |
||||
is_exclusive_lock = is_exclusive; |
||||
left_neg_inf = left_key == toku_dbt_negative_infinity(); |
||||
left_pos_inf = left_key == toku_dbt_positive_infinity(); |
||||
left_key_size = toku_dbt_is_infinite(left_key) ? 0 : left_key->size; |
||||
if (right_key) { |
||||
right_neg_inf = right_key == toku_dbt_negative_infinity(); |
||||
right_pos_inf = right_key == toku_dbt_positive_infinity(); |
||||
right_key_size = toku_dbt_is_infinite(right_key) ? 0 : right_key->size; |
||||
} else { |
||||
right_neg_inf = left_neg_inf; |
||||
right_pos_inf = left_pos_inf; |
||||
right_key_size = 0; |
||||
} |
||||
} |
||||
|
||||
const DBT *range_buffer::iterator::record::get_left_key(void) const { |
||||
if (_header.left_neg_inf) { |
||||
return toku_dbt_negative_infinity(); |
||||
} else if (_header.left_pos_inf) { |
||||
return toku_dbt_positive_infinity(); |
||||
} else { |
||||
return &_left_key; |
||||
} |
||||
} |
||||
|
||||
const DBT *range_buffer::iterator::record::get_right_key(void) const { |
||||
if (_header.right_neg_inf) { |
||||
return toku_dbt_negative_infinity(); |
||||
} else if (_header.right_pos_inf) { |
||||
return toku_dbt_positive_infinity(); |
||||
} else { |
||||
return &_right_key; |
||||
} |
||||
} |
||||
|
||||
size_t range_buffer::iterator::record::size(void) const { |
||||
return sizeof(record_header) + _header.left_key_size + _header.right_key_size; |
||||
} |
||||
|
||||
void range_buffer::iterator::record::deserialize(const char *buf) { |
||||
size_t current = 0; |
||||
|
||||
// deserialize the header
|
||||
memcpy(&_header, buf, sizeof(record_header)); |
||||
current += sizeof(record_header); |
||||
|
||||
// deserialize the left key if necessary
|
||||
if (!_header.left_is_infinite()) { |
||||
// point the left DBT's buffer into ours
|
||||
toku_fill_dbt(&_left_key, buf + current, _header.left_key_size); |
||||
current += _header.left_key_size; |
||||
} |
||||
|
||||
// deserialize the right key if necessary
|
||||
if (!_header.right_is_infinite()) { |
||||
if (_header.right_key_size == 0) { |
||||
toku_copyref_dbt(&_right_key, _left_key); |
||||
} else { |
||||
toku_fill_dbt(&_right_key, buf + current, _header.right_key_size); |
||||
} |
||||
} |
||||
} |
||||
|
||||
toku::range_buffer::iterator::iterator() |
||||
: _ma_chunk_iterator(nullptr), |
||||
_current_chunk_base(nullptr), |
||||
_current_chunk_offset(0), |
||||
_current_chunk_max(0), |
||||
_current_rec_size(0) {} |
||||
|
||||
toku::range_buffer::iterator::iterator(const range_buffer *buffer) |
||||
: _ma_chunk_iterator(&buffer->_arena), |
||||
_current_chunk_base(nullptr), |
||||
_current_chunk_offset(0), |
||||
_current_chunk_max(0), |
||||
_current_rec_size(0) { |
||||
reset_current_chunk(); |
||||
} |
||||
|
||||
void range_buffer::iterator::reset_current_chunk() { |
||||
_current_chunk_base = _ma_chunk_iterator.current(&_current_chunk_max); |
||||
_current_chunk_offset = 0; |
||||
} |
||||
|
||||
bool range_buffer::iterator::current(record *rec) { |
||||
if (_current_chunk_offset < _current_chunk_max) { |
||||
const char *buf = reinterpret_cast<const char *>(_current_chunk_base); |
||||
rec->deserialize(buf + _current_chunk_offset); |
||||
_current_rec_size = rec->size(); |
||||
return true; |
||||
} else { |
||||
return false; |
||||
} |
||||
} |
||||
|
||||
// move the iterator to the next record in the buffer
|
||||
void range_buffer::iterator::next(void) { |
||||
invariant(_current_chunk_offset < _current_chunk_max); |
||||
invariant(_current_rec_size > 0); |
||||
|
||||
// the next record is _current_rec_size bytes forward
|
||||
_current_chunk_offset += _current_rec_size; |
||||
// now, we don't know how big the current is, set it to 0.
|
||||
_current_rec_size = 0; |
||||
|
||||
if (_current_chunk_offset >= _current_chunk_max) { |
||||
// current chunk is exhausted, try moving to the next one
|
||||
if (_ma_chunk_iterator.more()) { |
||||
_ma_chunk_iterator.next(); |
||||
reset_current_chunk(); |
||||
} |
||||
} |
||||
} |
||||
|
||||
void range_buffer::create(void) { |
||||
// allocate buffer space lazily instead of on creation. this way,
|
||||
// no malloc/free is done if the transaction ends up taking no locks.
|
||||
_arena.create(0); |
||||
_num_ranges = 0; |
||||
} |
||||
|
||||
void range_buffer::append(const DBT *left_key, const DBT *right_key, |
||||
bool is_write_request) { |
||||
// if the keys are equal, then only one copy is stored.
|
||||
if (toku_dbt_equals(left_key, right_key)) { |
||||
invariant(left_key->size <= MAX_KEY_SIZE); |
||||
append_point(left_key, is_write_request); |
||||
} else { |
||||
invariant(left_key->size <= MAX_KEY_SIZE); |
||||
invariant(right_key->size <= MAX_KEY_SIZE); |
||||
append_range(left_key, right_key, is_write_request); |
||||
} |
||||
_num_ranges++; |
||||
} |
||||
|
||||
bool range_buffer::is_empty(void) const { return total_memory_size() == 0; } |
||||
|
||||
uint64_t range_buffer::total_memory_size(void) const { |
||||
return _arena.total_size_in_use(); |
||||
} |
||||
|
||||
int range_buffer::get_num_ranges(void) const { return _num_ranges; } |
||||
|
||||
void range_buffer::destroy(void) { _arena.destroy(); } |
||||
|
||||
void range_buffer::append_range(const DBT *left_key, const DBT *right_key, |
||||
bool is_exclusive) { |
||||
size_t record_length = |
||||
sizeof(record_header) + left_key->size + right_key->size; |
||||
char *buf = reinterpret_cast<char *>(_arena.malloc_from_arena(record_length)); |
||||
|
||||
record_header h; |
||||
h.init(left_key, right_key, is_exclusive); |
||||
|
||||
// serialize the header
|
||||
memcpy(buf, &h, sizeof(record_header)); |
||||
buf += sizeof(record_header); |
||||
|
||||
// serialize the left key if necessary
|
||||
if (!h.left_is_infinite()) { |
||||
memcpy(buf, left_key->data, left_key->size); |
||||
buf += left_key->size; |
||||
} |
||||
|
||||
// serialize the right key if necessary
|
||||
if (!h.right_is_infinite()) { |
||||
memcpy(buf, right_key->data, right_key->size); |
||||
} |
||||
} |
||||
|
||||
void range_buffer::append_point(const DBT *key, bool is_exclusive) { |
||||
size_t record_length = sizeof(record_header) + key->size; |
||||
char *buf = reinterpret_cast<char *>(_arena.malloc_from_arena(record_length)); |
||||
|
||||
record_header h; |
||||
h.init(key, nullptr, is_exclusive); |
||||
|
||||
// serialize the header
|
||||
memcpy(buf, &h, sizeof(record_header)); |
||||
buf += sizeof(record_header); |
||||
|
||||
// serialize the key if necessary
|
||||
if (!h.left_is_infinite()) { |
||||
memcpy(buf, key->data, key->size); |
||||
} |
||||
} |
||||
|
||||
} /* namespace toku */ |
||||
#endif // OS_WIN
|
||||
#endif // ROCKSDB_LITE
|
||||
@ -0,0 +1,177 @@ |
||||
/* -*- mode: C++; c-basic-offset: 4; indent-tabs-mode: nil -*- */ |
||||
// vim: ft=cpp:expandtab:ts=8:sw=4:softtabstop=4:
|
||||
#ident "$Id$" |
||||
/*======
|
||||
This file is part of PerconaFT. |
||||
|
||||
|
||||
Copyright (c) 2006, 2015, Percona and/or its affiliates. All rights reserved. |
||||
|
||||
PerconaFT is free software: you can redistribute it and/or modify |
||||
it under the terms of the GNU General Public License, version 2, |
||||
as published by the Free Software Foundation. |
||||
|
||||
PerconaFT is distributed in the hope that it will be useful, |
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
GNU General Public License for more details. |
||||
|
||||
You should have received a copy of the GNU General Public License |
||||
along with PerconaFT. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
---------------------------------------- |
||||
|
||||
PerconaFT is free software: you can redistribute it and/or modify |
||||
it under the terms of the GNU Affero General Public License, version 3, |
||||
as published by the Free Software Foundation. |
||||
|
||||
PerconaFT is distributed in the hope that it will be useful, |
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
GNU Affero General Public License for more details. |
||||
|
||||
You should have received a copy of the GNU Affero General Public License |
||||
along with PerconaFT. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
---------------------------------------- |
||||
|
||||
Licensed under the Apache License, Version 2.0 (the "License"); |
||||
you may not use this file except in compliance with the License. |
||||
You may obtain a copy of the License at |
||||
|
||||
http://www.apache.org/licenses/LICENSE-2.0
|
||||
|
||||
Unless required by applicable law or agreed to in writing, software |
||||
distributed under the License is distributed on an "AS IS" BASIS, |
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
||||
See the License for the specific language governing permissions and |
||||
======= */ |
||||
|
||||
#ident \ |
||||
"Copyright (c) 2006, 2015, Percona and/or its affiliates. All rights reserved." |
||||
|
||||
#pragma once |
||||
|
||||
#include <inttypes.h> |
||||
#include <stdint.h> |
||||
|
||||
#include "../util/dbt.h" |
||||
#include "../util/memarena.h" |
||||
|
||||
namespace toku { |
||||
|
||||
// a key range buffer represents a set of key ranges that can
|
||||
// be stored, iterated over, and then destroyed all at once.
|
||||
class range_buffer { |
||||
private: |
||||
// the key range buffer is a bunch of records in a row.
|
||||
// each record has the following header, followed by the
|
||||
// left key and right key data payload, if applicable.
|
||||
// we limit keys to be 2^16, since we store lengths as 2 bytes.
|
||||
static const size_t MAX_KEY_SIZE = 1 << 16; |
||||
|
||||
struct record_header { |
||||
bool left_neg_inf; |
||||
bool left_pos_inf; |
||||
bool right_pos_inf; |
||||
bool right_neg_inf; |
||||
uint16_t left_key_size; |
||||
uint16_t right_key_size; |
||||
bool is_exclusive_lock; |
||||
|
||||
bool left_is_infinite(void) const; |
||||
|
||||
bool right_is_infinite(void) const; |
||||
|
||||
void init(const DBT *left_key, const DBT *right_key, bool is_exclusive); |
||||
}; |
||||
// PORT static_assert(sizeof(record_header) == 8, "record header format is
|
||||
// off");
|
||||
|
||||
public: |
||||
// the iterator abstracts reading over a buffer of variable length
|
||||
// records one by one until there are no more left.
|
||||
class iterator { |
||||
public: |
||||
iterator(); |
||||
iterator(const range_buffer *buffer); |
||||
|
||||
// a record represents the user-view of a serialized key range.
|
||||
// it handles positive and negative infinity and the optimized
|
||||
// point range case, where left and right points share memory.
|
||||
class record { |
||||
public: |
||||
// get a read-only pointer to the left key of this record's range
|
||||
const DBT *get_left_key(void) const; |
||||
|
||||
// get a read-only pointer to the right key of this record's range
|
||||
const DBT *get_right_key(void) const; |
||||
|
||||
// how big is this record? this tells us where the next record is
|
||||
size_t size(void) const; |
||||
|
||||
bool get_exclusive_flag() const { return _header.is_exclusive_lock; } |
||||
|
||||
// populate a record header and point our DBT's
|
||||
// buffers into ours if they are not infinite.
|
||||
void deserialize(const char *buf); |
||||
|
||||
private: |
||||
record_header _header; |
||||
DBT _left_key; |
||||
DBT _right_key; |
||||
}; |
||||
|
||||
// populate the given record object with the current
|
||||
// the memory referred to by record is valid for only
|
||||
// as long as the record exists.
|
||||
bool current(record *rec); |
||||
|
||||
// move the iterator to the next record in the buffer
|
||||
void next(void); |
||||
|
||||
private: |
||||
void reset_current_chunk(); |
||||
|
||||
// the key range buffer we are iterating over, the current
|
||||
// offset in that buffer, and the size of the current record.
|
||||
memarena::chunk_iterator _ma_chunk_iterator; |
||||
const void *_current_chunk_base; |
||||
size_t _current_chunk_offset; |
||||
size_t _current_chunk_max; |
||||
size_t _current_rec_size; |
||||
}; |
||||
|
||||
// allocate buffer space lazily instead of on creation. this way,
|
||||
// no malloc/free is done if the transaction ends up taking no locks.
|
||||
void create(void); |
||||
|
||||
// append a left/right key range to the buffer.
|
||||
// if the keys are equal, then only one copy is stored.
|
||||
void append(const DBT *left_key, const DBT *right_key, |
||||
bool is_write_request = false); |
||||
|
||||
// is this range buffer empty?
|
||||
bool is_empty(void) const; |
||||
|
||||
// how much memory is being used by this range buffer?
|
||||
uint64_t total_memory_size(void) const; |
||||
|
||||
// how many ranges are stored in this range buffer?
|
||||
int get_num_ranges(void) const; |
||||
|
||||
void destroy(void); |
||||
|
||||
private: |
||||
memarena _arena; |
||||
int _num_ranges; |
||||
|
||||
void append_range(const DBT *left_key, const DBT *right_key, |
||||
bool is_write_request); |
||||
|
||||
// append a point to the buffer. this is the space/time saving
|
||||
// optimization for key ranges where left == right.
|
||||
void append_point(const DBT *key, bool is_write_request); |
||||
}; |
||||
|
||||
} /* namespace toku */ |
||||
@ -0,0 +1,519 @@ |
||||
/* -*- mode: C++; c-basic-offset: 4; indent-tabs-mode: nil -*- */ |
||||
// vim: ft=cpp:expandtab:ts=8:sw=4:softtabstop=4:
|
||||
#ifndef ROCKSDB_LITE |
||||
#ifndef OS_WIN |
||||
#ident "$Id$" |
||||
/*======
|
||||
This file is part of PerconaFT. |
||||
|
||||
|
||||
Copyright (c) 2006, 2015, Percona and/or its affiliates. All rights reserved. |
||||
|
||||
PerconaFT is free software: you can redistribute it and/or modify |
||||
it under the terms of the GNU General Public License, version 2, |
||||
as published by the Free Software Foundation. |
||||
|
||||
PerconaFT is distributed in the hope that it will be useful, |
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
GNU General Public License for more details. |
||||
|
||||
You should have received a copy of the GNU General Public License |
||||
along with PerconaFT. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
---------------------------------------- |
||||
|
||||
PerconaFT is free software: you can redistribute it and/or modify |
||||
it under the terms of the GNU Affero General Public License, version 3, |
||||
as published by the Free Software Foundation. |
||||
|
||||
PerconaFT is distributed in the hope that it will be useful, |
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
GNU Affero General Public License for more details. |
||||
|
||||
You should have received a copy of the GNU Affero General Public License |
||||
along with PerconaFT. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
---------------------------------------- |
||||
|
||||
Licensed under the Apache License, Version 2.0 (the "License"); |
||||
you may not use this file except in compliance with the License. |
||||
You may obtain a copy of the License at |
||||
|
||||
http://www.apache.org/licenses/LICENSE-2.0
|
||||
|
||||
Unless required by applicable law or agreed to in writing, software |
||||
distributed under the License is distributed on an "AS IS" BASIS, |
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
||||
See the License for the specific language governing permissions and |
||||
======= */ |
||||
|
||||
#ident \ |
||||
"Copyright (c) 2006, 2015, Percona and/or its affiliates. All rights reserved." |
||||
|
||||
#include "treenode.h" |
||||
|
||||
#include "../portability/toku_race_tools.h" |
||||
|
||||
namespace toku { |
||||
|
||||
// TODO: source location info might have to be pulled up one caller
|
||||
// to be useful
|
||||
void treenode::mutex_lock(void) { toku_mutex_lock(&m_mutex); } |
||||
|
||||
void treenode::mutex_unlock(void) { toku_mutex_unlock(&m_mutex); } |
||||
|
||||
void treenode::init(const comparator *cmp) { |
||||
m_txnid = TXNID_NONE; |
||||
m_is_root = false; |
||||
m_is_empty = true; |
||||
m_cmp = cmp; |
||||
|
||||
m_is_shared = false; |
||||
m_owners = nullptr; |
||||
|
||||
// use an adaptive mutex at each node since we expect the time the
|
||||
// lock is held to be relatively short compared to a context switch.
|
||||
// indeed, this improves performance at high thread counts considerably.
|
||||
memset(&m_mutex, 0, sizeof(toku_mutex_t)); |
||||
toku_pthread_mutexattr_t attr; |
||||
toku_mutexattr_init(&attr); |
||||
toku_mutexattr_settype(&attr, TOKU_MUTEX_ADAPTIVE); |
||||
toku_mutex_init(treenode_mutex_key, &m_mutex, &attr); |
||||
toku_mutexattr_destroy(&attr); |
||||
m_left_child.set(nullptr); |
||||
m_right_child.set(nullptr); |
||||
} |
||||
|
||||
void treenode::create_root(const comparator *cmp) { |
||||
init(cmp); |
||||
m_is_root = true; |
||||
} |
||||
|
||||
void treenode::destroy_root(void) { |
||||
invariant(is_root()); |
||||
invariant(is_empty()); |
||||
toku_mutex_destroy(&m_mutex); |
||||
m_cmp = nullptr; |
||||
} |
||||
|
||||
void treenode::set_range_and_txnid(const keyrange &range, TXNID txnid, |
||||
bool is_shared) { |
||||
// allocates a new copy of the range for this node
|
||||
m_range.create_copy(range); |
||||
m_txnid = txnid; |
||||
m_is_shared = is_shared; |
||||
m_is_empty = false; |
||||
} |
||||
|
||||
bool treenode::is_root(void) { return m_is_root; } |
||||
|
||||
bool treenode::is_empty(void) { return m_is_empty; } |
||||
|
||||
bool treenode::range_overlaps(const keyrange &range) { |
||||
return m_range.overlaps(*m_cmp, range); |
||||
} |
||||
|
||||
treenode *treenode::alloc(const comparator *cmp, const keyrange &range, |
||||
TXNID txnid, bool is_shared) { |
||||
treenode *XCALLOC(node); |
||||
node->init(cmp); |
||||
node->set_range_and_txnid(range, txnid, is_shared); |
||||
return node; |
||||
} |
||||
|
||||
void treenode::swap_in_place(treenode *node1, treenode *node2) { |
||||
keyrange tmp_range = node1->m_range; |
||||
TXNID tmp_txnid = node1->m_txnid; |
||||
node1->m_range = node2->m_range; |
||||
node1->m_txnid = node2->m_txnid; |
||||
node2->m_range = tmp_range; |
||||
node2->m_txnid = tmp_txnid; |
||||
|
||||
bool tmp_is_shared = node1->m_is_shared; |
||||
node1->m_is_shared = node2->m_is_shared; |
||||
node2->m_is_shared = tmp_is_shared; |
||||
|
||||
auto tmp_m_owners = node1->m_owners; |
||||
node1->m_owners = node2->m_owners; |
||||
node2->m_owners = tmp_m_owners; |
||||
} |
||||
|
||||
bool treenode::add_shared_owner(TXNID txnid) { |
||||
assert(m_is_shared); |
||||
if (txnid == m_txnid) |
||||
return false; // acquiring a lock on the same range by the same trx
|
||||
|
||||
if (m_txnid != TXNID_SHARED) { |
||||
m_owners = new TxnidVector; |
||||
m_owners->insert(m_txnid); |
||||
m_txnid = TXNID_SHARED; |
||||
} |
||||
m_owners->insert(txnid); |
||||
return true; |
||||
} |
||||
|
||||
void treenode::free(treenode *node) { |
||||
// destroy the range, freeing any copied keys
|
||||
node->m_range.destroy(); |
||||
|
||||
if (node->m_owners) { |
||||
delete node->m_owners; |
||||
node->m_owners = nullptr; // need this?
|
||||
} |
||||
|
||||
// the root is simply marked as empty.
|
||||
if (node->is_root()) { |
||||
// PORT toku_mutex_assert_locked(&node->m_mutex);
|
||||
node->m_is_empty = true; |
||||
} else { |
||||
// PORT toku_mutex_assert_unlocked(&node->m_mutex);
|
||||
toku_mutex_destroy(&node->m_mutex); |
||||
toku_free(node); |
||||
} |
||||
} |
||||
|
||||
uint32_t treenode::get_depth_estimate(void) const { |
||||
const uint32_t left_est = m_left_child.depth_est; |
||||
const uint32_t right_est = m_right_child.depth_est; |
||||
return (left_est > right_est ? left_est : right_est) + 1; |
||||
} |
||||
|
||||
treenode *treenode::find_node_with_overlapping_child( |
||||
const keyrange &range, const keyrange::comparison *cmp_hint) { |
||||
// determine which child to look at based on a comparison. if we were
|
||||
// given a comparison hint, use that. otherwise, compare them now.
|
||||
keyrange::comparison c = |
||||
cmp_hint ? *cmp_hint : range.compare(*m_cmp, m_range); |
||||
|
||||
treenode *child; |
||||
if (c == keyrange::comparison::LESS_THAN) { |
||||
child = lock_and_rebalance_left(); |
||||
} else { |
||||
// The caller (locked_keyrange::acquire) handles the case where
|
||||
// the root of the locked_keyrange is the node that overlaps.
|
||||
// range is guaranteed not to overlap this node.
|
||||
invariant(c == keyrange::comparison::GREATER_THAN); |
||||
child = lock_and_rebalance_right(); |
||||
} |
||||
|
||||
// if the search would lead us to an empty subtree (child == nullptr),
|
||||
// or the child overlaps, then we know this node is the parent we want.
|
||||
// otherwise we need to recur into that child.
|
||||
if (child == nullptr) { |
||||
return this; |
||||
} else { |
||||
c = range.compare(*m_cmp, child->m_range); |
||||
if (c == keyrange::comparison::EQUALS || |
||||
c == keyrange::comparison::OVERLAPS) { |
||||
child->mutex_unlock(); |
||||
return this; |
||||
} else { |
||||
// unlock this node before recurring into the locked child,
|
||||
// passing in a comparison hint since we just comapred range
|
||||
// to the child's range.
|
||||
mutex_unlock(); |
||||
return child->find_node_with_overlapping_child(range, &c); |
||||
} |
||||
} |
||||
} |
||||
|
||||
bool treenode::insert(const keyrange &range, TXNID txnid, bool is_shared) { |
||||
int rc = true; |
||||
// choose a child to check. if that child is null, then insert the new node
|
||||
// there. otherwise recur down that child's subtree
|
||||
keyrange::comparison c = range.compare(*m_cmp, m_range); |
||||
if (c == keyrange::comparison::LESS_THAN) { |
||||
treenode *left_child = lock_and_rebalance_left(); |
||||
if (left_child == nullptr) { |
||||
left_child = treenode::alloc(m_cmp, range, txnid, is_shared); |
||||
m_left_child.set(left_child); |
||||
} else { |
||||
left_child->insert(range, txnid, is_shared); |
||||
left_child->mutex_unlock(); |
||||
} |
||||
} else if (c == keyrange::comparison::GREATER_THAN) { |
||||
// invariant(c == keyrange::comparison::GREATER_THAN);
|
||||
treenode *right_child = lock_and_rebalance_right(); |
||||
if (right_child == nullptr) { |
||||
right_child = treenode::alloc(m_cmp, range, txnid, is_shared); |
||||
m_right_child.set(right_child); |
||||
} else { |
||||
right_child->insert(range, txnid, is_shared); |
||||
right_child->mutex_unlock(); |
||||
} |
||||
} else if (c == keyrange::comparison::EQUALS) { |
||||
invariant(is_shared); |
||||
invariant(m_is_shared); |
||||
rc = add_shared_owner(txnid); |
||||
} else { |
||||
invariant(0); |
||||
} |
||||
return rc; |
||||
} |
||||
|
||||
treenode *treenode::find_child_at_extreme(int direction, treenode **parent) { |
||||
treenode *child = |
||||
direction > 0 ? m_right_child.get_locked() : m_left_child.get_locked(); |
||||
|
||||
if (child) { |
||||
*parent = this; |
||||
treenode *child_extreme = child->find_child_at_extreme(direction, parent); |
||||
child->mutex_unlock(); |
||||
return child_extreme; |
||||
} else { |
||||
return this; |
||||
} |
||||
} |
||||
|
||||
treenode *treenode::find_leftmost_child(treenode **parent) { |
||||
return find_child_at_extreme(-1, parent); |
||||
} |
||||
|
||||
treenode *treenode::find_rightmost_child(treenode **parent) { |
||||
return find_child_at_extreme(1, parent); |
||||
} |
||||
|
||||
treenode *treenode::remove_root_of_subtree() { |
||||
// if this node has no children, just free it and return null
|
||||
if (m_left_child.ptr == nullptr && m_right_child.ptr == nullptr) { |
||||
// treenode::free requires that non-root nodes are unlocked
|
||||
if (!is_root()) { |
||||
mutex_unlock(); |
||||
} |
||||
treenode::free(this); |
||||
return nullptr; |
||||
} |
||||
|
||||
// we have a child, so get either the in-order successor or
|
||||
// predecessor of this node to be our replacement.
|
||||
// replacement_parent is updated by the find functions as
|
||||
// they recur down the tree, so initialize it to this.
|
||||
treenode *child, *replacement; |
||||
treenode *replacement_parent = this; |
||||
if (m_left_child.ptr != nullptr) { |
||||
child = m_left_child.get_locked(); |
||||
replacement = child->find_rightmost_child(&replacement_parent); |
||||
invariant(replacement == child || replacement_parent != this); |
||||
|
||||
// detach the replacement from its parent
|
||||
if (replacement_parent == this) { |
||||
m_left_child = replacement->m_left_child; |
||||
} else { |
||||
replacement_parent->m_right_child = replacement->m_left_child; |
||||
} |
||||
} else { |
||||
child = m_right_child.get_locked(); |
||||
replacement = child->find_leftmost_child(&replacement_parent); |
||||
invariant(replacement == child || replacement_parent != this); |
||||
|
||||
// detach the replacement from its parent
|
||||
if (replacement_parent == this) { |
||||
m_right_child = replacement->m_right_child; |
||||
} else { |
||||
replacement_parent->m_left_child = replacement->m_right_child; |
||||
} |
||||
} |
||||
child->mutex_unlock(); |
||||
|
||||
// swap in place with the detached replacement, then destroy it
|
||||
treenode::swap_in_place(replacement, this); |
||||
treenode::free(replacement); |
||||
|
||||
return this; |
||||
} |
||||
|
||||
void treenode::recursive_remove(void) { |
||||
treenode *left = m_left_child.ptr; |
||||
if (left) { |
||||
left->recursive_remove(); |
||||
} |
||||
m_left_child.set(nullptr); |
||||
|
||||
treenode *right = m_right_child.ptr; |
||||
if (right) { |
||||
right->recursive_remove(); |
||||
} |
||||
m_right_child.set(nullptr); |
||||
|
||||
// we do not take locks on the way down, so we know non-root nodes
|
||||
// are unlocked here and the caller is required to pass a locked
|
||||
// root, so this free is correct.
|
||||
treenode::free(this); |
||||
} |
||||
|
||||
void treenode::remove_shared_owner(TXNID txnid) { |
||||
assert(m_owners->size() > 1); |
||||
m_owners->erase(txnid); |
||||
assert(m_owners->size() > 0); |
||||
/* if there is just one owner left, move it to m_txnid */ |
||||
if (m_owners->size() == 1) { |
||||
m_txnid = *m_owners->begin(); |
||||
delete m_owners; |
||||
m_owners = nullptr; |
||||
} |
||||
} |
||||
|
||||
treenode *treenode::remove(const keyrange &range, TXNID txnid) { |
||||
treenode *child; |
||||
// if the range is equal to this node's range, then just remove
|
||||
// the root of this subtree. otherwise search down the tree
|
||||
// in either the left or right children.
|
||||
keyrange::comparison c = range.compare(*m_cmp, m_range); |
||||
switch (c) { |
||||
case keyrange::comparison::EQUALS: { |
||||
// if we are the only owners, remove. Otherwise, just remove
|
||||
// us from the owners list.
|
||||
if (txnid != TXNID_ANY && has_multiple_owners()) { |
||||
remove_shared_owner(txnid); |
||||
return this; |
||||
} else { |
||||
return remove_root_of_subtree(); |
||||
} |
||||
} |
||||
case keyrange::comparison::LESS_THAN: |
||||
child = m_left_child.get_locked(); |
||||
invariant_notnull(child); |
||||
child = child->remove(range, txnid); |
||||
|
||||
// unlock the child if there still is one.
|
||||
// regardless, set the right child pointer
|
||||
if (child) { |
||||
child->mutex_unlock(); |
||||
} |
||||
m_left_child.set(child); |
||||
break; |
||||
case keyrange::comparison::GREATER_THAN: |
||||
child = m_right_child.get_locked(); |
||||
invariant_notnull(child); |
||||
child = child->remove(range, txnid); |
||||
|
||||
// unlock the child if there still is one.
|
||||
// regardless, set the right child pointer
|
||||
if (child) { |
||||
child->mutex_unlock(); |
||||
} |
||||
m_right_child.set(child); |
||||
break; |
||||
case keyrange::comparison::OVERLAPS: |
||||
// shouldn't be overlapping, since the tree is
|
||||
// non-overlapping and this range must exist
|
||||
abort(); |
||||
} |
||||
|
||||
return this; |
||||
} |
||||
|
||||
bool treenode::left_imbalanced(int threshold) const { |
||||
uint32_t left_depth = m_left_child.depth_est; |
||||
uint32_t right_depth = m_right_child.depth_est; |
||||
return m_left_child.ptr != nullptr && left_depth > threshold + right_depth; |
||||
} |
||||
|
||||
bool treenode::right_imbalanced(int threshold) const { |
||||
uint32_t left_depth = m_left_child.depth_est; |
||||
uint32_t right_depth = m_right_child.depth_est; |
||||
return m_right_child.ptr != nullptr && right_depth > threshold + left_depth; |
||||
} |
||||
|
||||
// effect: rebalances the subtree rooted at this node
|
||||
// using AVL style O(1) rotations. unlocks this
|
||||
// node if it is not the new root of the subtree.
|
||||
// requires: node is locked by this thread, children are not
|
||||
// returns: locked root node of the rebalanced tree
|
||||
treenode *treenode::maybe_rebalance(void) { |
||||
// if we end up not rotating at all, the new root is this
|
||||
treenode *new_root = this; |
||||
treenode *child = nullptr; |
||||
|
||||
if (left_imbalanced(IMBALANCE_THRESHOLD)) { |
||||
child = m_left_child.get_locked(); |
||||
if (child->right_imbalanced(0)) { |
||||
treenode *grandchild = child->m_right_child.get_locked(); |
||||
|
||||
child->m_right_child = grandchild->m_left_child; |
||||
grandchild->m_left_child.set(child); |
||||
|
||||
m_left_child = grandchild->m_right_child; |
||||
grandchild->m_right_child.set(this); |
||||
|
||||
new_root = grandchild; |
||||
} else { |
||||
m_left_child = child->m_right_child; |
||||
child->m_right_child.set(this); |
||||
new_root = child; |
||||
} |
||||
} else if (right_imbalanced(IMBALANCE_THRESHOLD)) { |
||||
child = m_right_child.get_locked(); |
||||
if (child->left_imbalanced(0)) { |
||||
treenode *grandchild = child->m_left_child.get_locked(); |
||||
|
||||
child->m_left_child = grandchild->m_right_child; |
||||
grandchild->m_right_child.set(child); |
||||
|
||||
m_right_child = grandchild->m_left_child; |
||||
grandchild->m_left_child.set(this); |
||||
|
||||
new_root = grandchild; |
||||
} else { |
||||
m_right_child = child->m_left_child; |
||||
child->m_left_child.set(this); |
||||
new_root = child; |
||||
} |
||||
} |
||||
|
||||
// up to three nodes may be locked.
|
||||
// - this
|
||||
// - child
|
||||
// - grandchild (but if it is locked, its the new root)
|
||||
//
|
||||
// one of them is the new root. we unlock everything except the new root.
|
||||
if (child && child != new_root) { |
||||
TOKU_VALGRIND_RESET_MUTEX_ORDERING_INFO(&child->m_mutex); |
||||
child->mutex_unlock(); |
||||
} |
||||
if (this != new_root) { |
||||
TOKU_VALGRIND_RESET_MUTEX_ORDERING_INFO(&m_mutex); |
||||
mutex_unlock(); |
||||
} |
||||
TOKU_VALGRIND_RESET_MUTEX_ORDERING_INFO(&new_root->m_mutex); |
||||
return new_root; |
||||
} |
||||
|
||||
treenode *treenode::lock_and_rebalance_left(void) { |
||||
treenode *child = m_left_child.get_locked(); |
||||
if (child) { |
||||
treenode *new_root = child->maybe_rebalance(); |
||||
m_left_child.set(new_root); |
||||
child = new_root; |
||||
} |
||||
return child; |
||||
} |
||||
|
||||
treenode *treenode::lock_and_rebalance_right(void) { |
||||
treenode *child = m_right_child.get_locked(); |
||||
if (child) { |
||||
treenode *new_root = child->maybe_rebalance(); |
||||
m_right_child.set(new_root); |
||||
child = new_root; |
||||
} |
||||
return child; |
||||
} |
||||
|
||||
void treenode::child_ptr::set(treenode *node) { |
||||
ptr = node; |
||||
depth_est = ptr ? ptr->get_depth_estimate() : 0; |
||||
} |
||||
|
||||
treenode *treenode::child_ptr::get_locked(void) { |
||||
if (ptr) { |
||||
ptr->mutex_lock(); |
||||
depth_est = ptr->get_depth_estimate(); |
||||
} |
||||
return ptr; |
||||
} |
||||
|
||||
} /* namespace toku */ |
||||
#endif // OS_WIN
|
||||
#endif // ROCKSDB_LITE
|
||||
@ -0,0 +1,301 @@ |
||||
/* -*- mode: C++; c-basic-offset: 4; indent-tabs-mode: nil -*- */ |
||||
// vim: ft=cpp:expandtab:ts=8:sw=2:softtabstop=2:
|
||||
#ident "$Id$" |
||||
/*======
|
||||
This file is part of PerconaFT. |
||||
|
||||
|
||||
Copyright (c) 2006, 2015, Percona and/or its affiliates. All rights reserved. |
||||
|
||||
PerconaFT is free software: you can redistribute it and/or modify |
||||
it under the terms of the GNU General Public License, version 2, |
||||
as published by the Free Software Foundation. |
||||
|
||||
PerconaFT is distributed in the hope that it will be useful, |
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
GNU General Public License for more details. |
||||
|
||||
You should have received a copy of the GNU General Public License |
||||
along with PerconaFT. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
---------------------------------------- |
||||
|
||||
PerconaFT is free software: you can redistribute it and/or modify |
||||
it under the terms of the GNU Affero General Public License, version 3, |
||||
as published by the Free Software Foundation. |
||||
|
||||
PerconaFT is distributed in the hope that it will be useful, |
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
GNU Affero General Public License for more details. |
||||
|
||||
You should have received a copy of the GNU Affero General Public License |
||||
along with PerconaFT. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
---------------------------------------- |
||||
|
||||
Licensed under the Apache License, Version 2.0 (the "License"); |
||||
you may not use this file except in compliance with the License. |
||||
You may obtain a copy of the License at |
||||
|
||||
http://www.apache.org/licenses/LICENSE-2.0
|
||||
|
||||
Unless required by applicable law or agreed to in writing, software |
||||
distributed under the License is distributed on an "AS IS" BASIS, |
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
||||
See the License for the specific language governing permissions and |
||||
======= */ |
||||
|
||||
#ident \ |
||||
"Copyright (c) 2006, 2015, Percona and/or its affiliates. All rights reserved." |
||||
|
||||
#pragma once |
||||
|
||||
#include <string.h> |
||||
|
||||
#include "../ft/comparator.h" |
||||
#include "../portability/memory.h" |
||||
#include "../portability/toku_pthread.h" |
||||
// PORT: we need LTM_STATUS
|
||||
#include "../ft/ft-status.h" |
||||
#include "../portability/txn_subst.h" |
||||
#include "keyrange.h" |
||||
|
||||
namespace toku { |
||||
|
||||
// a node in a tree with its own mutex
|
||||
// - range is the "key" of this node
|
||||
// - txnid is the single txnid associated with this node
|
||||
// - left and right children may be null
|
||||
//
|
||||
// to build a tree on top of this abstraction, the user:
|
||||
// - provides memory for a root node, initializes it via create_root()
|
||||
// - performs tree operations on the root node. memory management
|
||||
// below the root node is handled by the abstraction, not the user.
|
||||
// this pattern:
|
||||
// - guaruntees a root node always exists.
|
||||
// - does not allow for rebalances on the root node
|
||||
|
||||
class treenode { |
||||
public: |
||||
// every treenode function has some common requirements:
|
||||
// - node is locked and children are never locked
|
||||
// - node may be unlocked if no other thread has visibility
|
||||
|
||||
// effect: create the root node
|
||||
void create_root(const comparator *cmp); |
||||
|
||||
// effect: destroys the root node
|
||||
void destroy_root(void); |
||||
|
||||
// effect: sets the txnid and copies the given range for this node
|
||||
void set_range_and_txnid(const keyrange &range, TXNID txnid, bool is_shared); |
||||
|
||||
// returns: true iff this node is marked as empty
|
||||
bool is_empty(void); |
||||
|
||||
// returns: true if this is the root node, denoted by a null parent
|
||||
bool is_root(void); |
||||
|
||||
// returns: true if the given range overlaps with this node's range
|
||||
bool range_overlaps(const keyrange &range); |
||||
|
||||
// effect: locks the node
|
||||
void mutex_lock(void); |
||||
|
||||
// effect: unlocks the node
|
||||
void mutex_unlock(void); |
||||
|
||||
// return: node whose child overlaps, or a child that is empty
|
||||
// and would contain range if it existed
|
||||
// given: if cmp_hint is non-null, then it is a precomputed
|
||||
// comparison of this node's range to the given range.
|
||||
treenode *find_node_with_overlapping_child( |
||||
const keyrange &range, const keyrange::comparison *cmp_hint); |
||||
|
||||
// effect: performs an in-order traversal of the ranges that overlap the
|
||||
// given range, calling function->fn() on each node that does
|
||||
// requires: function signature is: bool fn(const keyrange &range, TXNID
|
||||
// txnid) requires: fn returns true to keep iterating, false to stop iterating
|
||||
// requires: fn does not attempt to use any ranges read out by value
|
||||
// after removing a node with an overlapping range from the tree.
|
||||
template <class F> |
||||
void traverse_overlaps(const keyrange &range, F *function) { |
||||
keyrange::comparison c = range.compare(*m_cmp, m_range); |
||||
if (c == keyrange::comparison::EQUALS) { |
||||
// Doesn't matter if fn wants to keep going, there
|
||||
// is nothing left, so return.
|
||||
function->fn(m_range, m_txnid, m_is_shared, m_owners); |
||||
return; |
||||
} |
||||
|
||||
treenode *left = m_left_child.get_locked(); |
||||
if (left) { |
||||
if (c != keyrange::comparison::GREATER_THAN) { |
||||
// Target range is less than this node, or it overlaps this
|
||||
// node. There may be something on the left.
|
||||
left->traverse_overlaps(range, function); |
||||
} |
||||
left->mutex_unlock(); |
||||
} |
||||
|
||||
if (c == keyrange::comparison::OVERLAPS) { |
||||
bool keep_going = function->fn(m_range, m_txnid, m_is_shared, m_owners); |
||||
if (!keep_going) { |
||||
return; |
||||
} |
||||
} |
||||
|
||||
treenode *right = m_right_child.get_locked(); |
||||
if (right) { |
||||
if (c != keyrange::comparison::LESS_THAN) { |
||||
// Target range is greater than this node, or it overlaps this
|
||||
// node. There may be something on the right.
|
||||
right->traverse_overlaps(range, function); |
||||
} |
||||
right->mutex_unlock(); |
||||
} |
||||
} |
||||
|
||||
// effect: inserts the given range and txnid into a subtree, recursively
|
||||
// requires: range does not overlap with any node below the subtree
|
||||
bool insert(const keyrange &range, TXNID txnid, bool is_shared); |
||||
|
||||
// effect: removes the given range from the subtree
|
||||
// requires: range exists in the subtree
|
||||
// returns: the root of the resulting subtree
|
||||
treenode *remove(const keyrange &range, TXNID txnid); |
||||
|
||||
// effect: removes this node and all of its children, recursively
|
||||
// requires: every node at and below this node is unlocked
|
||||
void recursive_remove(void); |
||||
|
||||
private: |
||||
// the child_ptr is a light abstraction for the locking of
|
||||
// a child and the maintenence of its depth estimate.
|
||||
|
||||
struct child_ptr { |
||||
// set the child pointer
|
||||
void set(treenode *node); |
||||
|
||||
// get and lock this child if it exists
|
||||
treenode *get_locked(void); |
||||
|
||||
treenode *ptr; |
||||
uint32_t depth_est; |
||||
}; |
||||
|
||||
// the balance factor at which a node is considered imbalanced
|
||||
static const int32_t IMBALANCE_THRESHOLD = 2; |
||||
|
||||
// node-level mutex
|
||||
toku_mutex_t m_mutex; |
||||
|
||||
// the range and txnid for this node. the range contains a copy
|
||||
// of the keys originally inserted into the tree. nodes may
|
||||
// swap ranges. but at the end of the day, when a node is
|
||||
// destroyed, it frees the memory associated with whatever range
|
||||
// it has at the time of destruction.
|
||||
keyrange m_range; |
||||
|
||||
void remove_shared_owner(TXNID txnid); |
||||
|
||||
bool has_multiple_owners() { return (m_txnid == TXNID_SHARED); } |
||||
|
||||
private: |
||||
// Owner transaction id.
|
||||
// A value of TXNID_SHARED means this node has multiple owners
|
||||
TXNID m_txnid; |
||||
|
||||
// If true, this lock is a non-exclusive lock, and it can have either
|
||||
// one or several owners.
|
||||
bool m_is_shared; |
||||
|
||||
// List of the owners, or nullptr if there's just one owner.
|
||||
TxnidVector *m_owners; |
||||
|
||||
// two child pointers
|
||||
child_ptr m_left_child; |
||||
child_ptr m_right_child; |
||||
|
||||
// comparator for ranges
|
||||
// psergey-todo: Is there any sense to store the comparator in each tree
|
||||
// node?
|
||||
const comparator *m_cmp; |
||||
|
||||
// marked for the root node. the root node is never free()'d
|
||||
// when removed, but instead marked as empty.
|
||||
bool m_is_root; |
||||
|
||||
// marked for an empty node. only valid for the root.
|
||||
bool m_is_empty; |
||||
|
||||
// effect: initializes an empty node with the given comparator
|
||||
void init(const comparator *cmp); |
||||
|
||||
// requires: this is a shared node (m_is_shared==true)
|
||||
// effect: another transaction is added as an owner.
|
||||
// returns: true <=> added another owner
|
||||
// false <=> this transaction is already an owner
|
||||
bool add_shared_owner(TXNID txnid); |
||||
|
||||
// requires: *parent is initialized to something meaningful.
|
||||
// requires: subtree is non-empty
|
||||
// returns: the leftmost child of the given subtree
|
||||
// returns: a pointer to the parent of said child in *parent, only
|
||||
// if this function recurred, otherwise it is untouched.
|
||||
treenode *find_leftmost_child(treenode **parent); |
||||
|
||||
// requires: *parent is initialized to something meaningful.
|
||||
// requires: subtree is non-empty
|
||||
// returns: the rightmost child of the given subtree
|
||||
// returns: a pointer to the parent of said child in *parent, only
|
||||
// if this function recurred, otherwise it is untouched.
|
||||
treenode *find_rightmost_child(treenode **parent); |
||||
|
||||
// effect: remove the root of this subtree, destroying the old root
|
||||
// returns: the new root of the subtree
|
||||
treenode *remove_root_of_subtree(void); |
||||
|
||||
// requires: subtree is non-empty, direction is not 0
|
||||
// returns: the child of the subtree at either the left or rightmost extreme
|
||||
treenode *find_child_at_extreme(int direction, treenode **parent); |
||||
|
||||
// effect: retrieves and possibly rebalances the left child
|
||||
// returns: a locked left child, if it exists
|
||||
treenode *lock_and_rebalance_left(void); |
||||
|
||||
// effect: retrieves and possibly rebalances the right child
|
||||
// returns: a locked right child, if it exists
|
||||
treenode *lock_and_rebalance_right(void); |
||||
|
||||
// returns: the estimated depth of this subtree
|
||||
uint32_t get_depth_estimate(void) const; |
||||
|
||||
// returns: true iff left subtree depth is sufficiently less than the right
|
||||
bool left_imbalanced(int threshold) const; |
||||
|
||||
// returns: true iff right subtree depth is sufficiently greater than the left
|
||||
bool right_imbalanced(int threshold) const; |
||||
|
||||
// effect: performs an O(1) rebalance, which will "heal" an imbalance by at
|
||||
// most 1. effect: if the new root is not this node, then this node is
|
||||
// unlocked. returns: locked node representing the new root of the rebalanced
|
||||
// subtree
|
||||
treenode *maybe_rebalance(void); |
||||
|
||||
// returns: allocated treenode populated with a copy of the range and txnid
|
||||
static treenode *alloc(const comparator *cmp, const keyrange &range, |
||||
TXNID txnid, bool is_shared); |
||||
|
||||
// requires: node is a locked root node, or an unlocked non-root node
|
||||
static void free(treenode *node); |
||||
|
||||
// effect: swaps the range/txnid pairs for node1 and node2.
|
||||
static void swap_in_place(treenode *node1, treenode *node2); |
||||
|
||||
friend class concurrent_tree_unit_test; |
||||
}; |
||||
|
||||
} /* namespace toku */ |
||||
@ -0,0 +1,119 @@ |
||||
/* -*- mode: C++; c-basic-offset: 4; indent-tabs-mode: nil -*- */ |
||||
// vim: ft=cpp:expandtab:ts=8:sw=4:softtabstop=4:
|
||||
#ifndef ROCKSDB_LITE |
||||
#ifndef OS_WIN |
||||
#ident "$Id$" |
||||
/*======
|
||||
This file is part of PerconaFT. |
||||
|
||||
|
||||
Copyright (c) 2006, 2015, Percona and/or its affiliates. All rights reserved. |
||||
|
||||
PerconaFT is free software: you can redistribute it and/or modify |
||||
it under the terms of the GNU General Public License, version 2, |
||||
as published by the Free Software Foundation. |
||||
|
||||
PerconaFT is distributed in the hope that it will be useful, |
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
GNU General Public License for more details. |
||||
|
||||
You should have received a copy of the GNU General Public License |
||||
along with PerconaFT. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
---------------------------------------- |
||||
|
||||
PerconaFT is free software: you can redistribute it and/or modify |
||||
it under the terms of the GNU Affero General Public License, version 3, |
||||
as published by the Free Software Foundation. |
||||
|
||||
PerconaFT is distributed in the hope that it will be useful, |
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
GNU Affero General Public License for more details. |
||||
|
||||
You should have received a copy of the GNU Affero General Public License |
||||
along with PerconaFT. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
---------------------------------------- |
||||
|
||||
Licensed under the Apache License, Version 2.0 (the "License"); |
||||
you may not use this file except in compliance with the License. |
||||
You may obtain a copy of the License at |
||||
|
||||
http://www.apache.org/licenses/LICENSE-2.0
|
||||
|
||||
Unless required by applicable law or agreed to in writing, software |
||||
distributed under the License is distributed on an "AS IS" BASIS, |
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
||||
See the License for the specific language governing permissions and |
||||
======= */ |
||||
|
||||
#ident \ |
||||
"Copyright (c) 2006, 2015, Percona and/or its affiliates. All rights reserved." |
||||
|
||||
#include "txnid_set.h" |
||||
|
||||
#include "../db.h" |
||||
|
||||
namespace toku { |
||||
|
||||
int find_by_txnid(const TXNID &txnid_a, const TXNID &txnid_b); |
||||
int find_by_txnid(const TXNID &txnid_a, const TXNID &txnid_b) { |
||||
if (txnid_a < txnid_b) { |
||||
return -1; |
||||
} else if (txnid_a == txnid_b) { |
||||
return 0; |
||||
} else { |
||||
return 1; |
||||
} |
||||
} |
||||
|
||||
void txnid_set::create(void) { |
||||
// lazily allocate the underlying omt, since it is common
|
||||
// to create a txnid set and never put anything in it.
|
||||
m_txnids.create_no_array(); |
||||
} |
||||
|
||||
void txnid_set::destroy(void) { m_txnids.destroy(); } |
||||
|
||||
// Return true if the given transaction id is a member of the set.
|
||||
// Otherwise, return false.
|
||||
bool txnid_set::contains(TXNID txnid) const { |
||||
TXNID find_txnid; |
||||
int r = m_txnids.find_zero<TXNID, find_by_txnid>(txnid, &find_txnid, nullptr); |
||||
return r == 0 ? true : false; |
||||
} |
||||
|
||||
// Add a given txnid to the set
|
||||
void txnid_set::add(TXNID txnid) { |
||||
int r = m_txnids.insert<TXNID, find_by_txnid>(txnid, txnid, nullptr); |
||||
invariant(r == 0 || r == DB_KEYEXIST); |
||||
} |
||||
|
||||
// Delete a given txnid from the set.
|
||||
void txnid_set::remove(TXNID txnid) { |
||||
uint32_t idx; |
||||
int r = m_txnids.find_zero<TXNID, find_by_txnid>(txnid, nullptr, &idx); |
||||
if (r == 0) { |
||||
r = m_txnids.delete_at(idx); |
||||
invariant_zero(r); |
||||
} |
||||
} |
||||
|
||||
// Return the size of the set
|
||||
uint32_t txnid_set::size(void) const { return m_txnids.size(); } |
||||
|
||||
// Get the ith id in the set, assuming that the set is sorted.
|
||||
TXNID txnid_set::get(uint32_t i) const { |
||||
TXNID txnid; |
||||
int r = m_txnids.fetch(i, &txnid); |
||||
if (r == EINVAL) /* Shouldn't happen, avoid compiler warning */ |
||||
return TXNID_NONE; |
||||
invariant_zero(r); |
||||
return txnid; |
||||
} |
||||
|
||||
} /* namespace toku */ |
||||
#endif // OS_WIN
|
||||
#endif // ROCKSDB_LITE
|
||||
@ -0,0 +1,91 @@ |
||||
/* -*- mode: C++; c-basic-offset: 4; indent-tabs-mode: nil -*- */ |
||||
// vim: ft=cpp:expandtab:ts=8:sw=4:softtabstop=4:
|
||||
#ident "$Id$" |
||||
/*======
|
||||
This file is part of PerconaFT. |
||||
|
||||
|
||||
Copyright (c) 2006, 2015, Percona and/or its affiliates. All rights reserved. |
||||
|
||||
PerconaFT is free software: you can redistribute it and/or modify |
||||
it under the terms of the GNU General Public License, version 2, |
||||
as published by the Free Software Foundation. |
||||
|
||||
PerconaFT is distributed in the hope that it will be useful, |
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
GNU General Public License for more details. |
||||
|
||||
You should have received a copy of the GNU General Public License |
||||
along with PerconaFT. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
---------------------------------------- |
||||
|
||||
PerconaFT is free software: you can redistribute it and/or modify |
||||
it under the terms of the GNU Affero General Public License, version 3, |
||||
as published by the Free Software Foundation. |
||||
|
||||
PerconaFT is distributed in the hope that it will be useful, |
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
GNU Affero General Public License for more details. |
||||
|
||||
You should have received a copy of the GNU Affero General Public License |
||||
along with PerconaFT. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
---------------------------------------- |
||||
|
||||
Licensed under the Apache License, Version 2.0 (the "License"); |
||||
you may not use this file except in compliance with the License. |
||||
You may obtain a copy of the License at |
||||
|
||||
http://www.apache.org/licenses/LICENSE-2.0
|
||||
|
||||
Unless required by applicable law or agreed to in writing, software |
||||
distributed under the License is distributed on an "AS IS" BASIS, |
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
||||
See the License for the specific language governing permissions and |
||||
======= */ |
||||
|
||||
#ident \ |
||||
"Copyright (c) 2006, 2015, Percona and/or its affiliates. All rights reserved." |
||||
|
||||
#pragma once |
||||
|
||||
#include "../portability/txn_subst.h" |
||||
#include "../util/omt.h" |
||||
|
||||
namespace toku { |
||||
|
||||
class txnid_set { |
||||
public: |
||||
// effect: Creates an empty set. Does not malloc space for
|
||||
// any entries yet. That is done lazily on add().
|
||||
void create(void); |
||||
|
||||
// effect: Destroy the set's internals.
|
||||
void destroy(void); |
||||
|
||||
// returns: True if the given txnid is a member of the set.
|
||||
bool contains(TXNID id) const; |
||||
|
||||
// effect: Adds a given txnid to the set if it did not exist
|
||||
void add(TXNID txnid); |
||||
|
||||
// effect: Deletes a txnid from the set if it exists.
|
||||
void remove(TXNID txnid); |
||||
|
||||
// returns: Size of the set
|
||||
uint32_t size(void) const; |
||||
|
||||
// returns: The "i'th" id in the set, as if it were sorted.
|
||||
TXNID get(uint32_t i) const; |
||||
|
||||
private: |
||||
toku::omt<TXNID> m_txnids; |
||||
|
||||
friend class txnid_set_unit_test; |
||||
}; |
||||
ENSURE_POD(txnid_set); |
||||
|
||||
} /* namespace toku */ |
||||
@ -0,0 +1,212 @@ |
||||
/* -*- mode: C++; c-basic-offset: 4; indent-tabs-mode: nil -*- */ |
||||
// vim: ft=cpp:expandtab:ts=8:sw=4:softtabstop=4:
|
||||
#ifndef ROCKSDB_LITE |
||||
#ifndef OS_WIN |
||||
#ident "$Id$" |
||||
/*======
|
||||
This file is part of PerconaFT. |
||||
|
||||
|
||||
Copyright (c) 2006, 2015, Percona and/or its affiliates. All rights reserved. |
||||
|
||||
PerconaFT is free software: you can redistribute it and/or modify |
||||
it under the terms of the GNU General Public License, version 2, |
||||
as published by the Free Software Foundation. |
||||
|
||||
PerconaFT is distributed in the hope that it will be useful, |
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
GNU General Public License for more details. |
||||
|
||||
You should have received a copy of the GNU General Public License |
||||
along with PerconaFT. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
---------------------------------------- |
||||
|
||||
PerconaFT is free software: you can redistribute it and/or modify |
||||
it under the terms of the GNU Affero General Public License, version 3, |
||||
as published by the Free Software Foundation. |
||||
|
||||
PerconaFT is distributed in the hope that it will be useful, |
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
GNU Affero General Public License for more details. |
||||
|
||||
You should have received a copy of the GNU Affero General Public License |
||||
along with PerconaFT. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
---------------------------------------- |
||||
|
||||
Licensed under the Apache License, Version 2.0 (the "License"); |
||||
you may not use this file except in compliance with the License. |
||||
You may obtain a copy of the License at |
||||
|
||||
http://www.apache.org/licenses/LICENSE-2.0
|
||||
|
||||
Unless required by applicable law or agreed to in writing, software |
||||
distributed under the License is distributed on an "AS IS" BASIS, |
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
||||
See the License for the specific language governing permissions and |
||||
======= */ |
||||
|
||||
#ident \ |
||||
"Copyright (c) 2006, 2015, Percona and/or its affiliates. All rights reserved." |
||||
|
||||
#include "../db.h" |
||||
#include "../portability/memory.h" |
||||
// PORT #include <toku_assert.h>
|
||||
#include <memory.h> |
||||
#include <string.h> |
||||
|
||||
#include "txnid_set.h" |
||||
#include "wfg.h" |
||||
|
||||
namespace toku { |
||||
|
||||
// Create a lock request graph
|
||||
void wfg::create(void) { m_nodes.create(); } |
||||
|
||||
// Destroy the internals of the lock request graph
|
||||
void wfg::destroy(void) { |
||||
uint32_t n_nodes = m_nodes.size(); |
||||
for (uint32_t i = 0; i < n_nodes; i++) { |
||||
node *n; |
||||
int r = m_nodes.fetch(i, &n); |
||||
invariant_zero(r); |
||||
invariant_notnull(n); |
||||
if (r) continue; // Get rid of "may be used uninitialized" warning
|
||||
node::free(n); |
||||
} |
||||
m_nodes.destroy(); |
||||
} |
||||
|
||||
// Add an edge (a_id, b_id) to the graph
|
||||
void wfg::add_edge(TXNID a_txnid, TXNID b_txnid) { |
||||
node *a_node = find_create_node(a_txnid); |
||||
node *b_node = find_create_node(b_txnid); |
||||
a_node->edges.add(b_node->txnid); |
||||
} |
||||
|
||||
// Return true if a node with the given transaction id exists in the graph.
|
||||
// Return false otherwise.
|
||||
bool wfg::node_exists(TXNID txnid) { |
||||
node *n = find_node(txnid); |
||||
return n != NULL; |
||||
} |
||||
|
||||
bool wfg::cycle_exists_from_node(node *target, node *head, |
||||
std::function<void(TXNID)> reporter) { |
||||
bool cycle_found = false; |
||||
head->visited = true; |
||||
uint32_t n_edges = head->edges.size(); |
||||
for (uint32_t i = 0; i < n_edges && !cycle_found; i++) { |
||||
TXNID edge_id = head->edges.get(i); |
||||
if (target->txnid == edge_id) { |
||||
cycle_found = true; |
||||
if (reporter) reporter(edge_id); |
||||
} else { |
||||
node *new_head = find_node(edge_id); |
||||
if (new_head && !new_head->visited) { |
||||
cycle_found = cycle_exists_from_node(target, new_head, reporter); |
||||
if (cycle_found && reporter) reporter(edge_id); |
||||
} |
||||
} |
||||
} |
||||
head->visited = false; |
||||
return cycle_found; |
||||
} |
||||
|
||||
// Return true if there exists a cycle from a given transaction id in the graph.
|
||||
// Return false otherwise.
|
||||
bool wfg::cycle_exists_from_txnid(TXNID txnid, |
||||
std::function<void(TXNID)> reporter) { |
||||
node *a_node = find_node(txnid); |
||||
bool cycles_found = false; |
||||
if (a_node) { |
||||
cycles_found = cycle_exists_from_node(a_node, a_node, reporter); |
||||
} |
||||
return cycles_found; |
||||
} |
||||
|
||||
// Apply a given function f to all of the nodes in the graph. The apply
|
||||
// function returns when the function f is called for all of the nodes in the
|
||||
// graph, or the function f returns non-zero.
|
||||
void wfg::apply_nodes(int (*fn)(TXNID id, void *extra), void *extra) { |
||||
int r = 0; |
||||
uint32_t n_nodes = m_nodes.size(); |
||||
for (uint32_t i = 0; i < n_nodes && r == 0; i++) { |
||||
node *n; |
||||
r = m_nodes.fetch(i, &n); |
||||
invariant_zero(r); |
||||
if (r) continue; // Get rid of "may be used uninitialized" warning
|
||||
r = fn(n->txnid, extra); |
||||
} |
||||
} |
||||
|
||||
// Apply a given function f to all of the edges whose origin is a given node id.
|
||||
// The apply function returns when the function f is called for all edges in the
|
||||
// graph rooted at node id, or the function f returns non-zero.
|
||||
void wfg::apply_edges(TXNID txnid, |
||||
int (*fn)(TXNID txnid, TXNID edge_txnid, void *extra), |
||||
void *extra) { |
||||
node *n = find_node(txnid); |
||||
if (n) { |
||||
int r = 0; |
||||
uint32_t n_edges = n->edges.size(); |
||||
for (uint32_t i = 0; i < n_edges && r == 0; i++) { |
||||
r = fn(txnid, n->edges.get(i), extra); |
||||
} |
||||
} |
||||
} |
||||
|
||||
// find node by id
|
||||
wfg::node *wfg::find_node(TXNID txnid) { |
||||
node *n = nullptr; |
||||
int r = m_nodes.find_zero<TXNID, find_by_txnid>(txnid, &n, nullptr); |
||||
invariant(r == 0 || r == DB_NOTFOUND); |
||||
return n; |
||||
} |
||||
|
||||
// this is the omt comparison function
|
||||
// nodes are compared by their txnid.
|
||||
int wfg::find_by_txnid(node *const &node_a, const TXNID &txnid_b) { |
||||
TXNID txnid_a = node_a->txnid; |
||||
if (txnid_a < txnid_b) { |
||||
return -1; |
||||
} else if (txnid_a == txnid_b) { |
||||
return 0; |
||||
} else { |
||||
return 1; |
||||
} |
||||
} |
||||
|
||||
// insert a new node
|
||||
wfg::node *wfg::find_create_node(TXNID txnid) { |
||||
node *n; |
||||
uint32_t idx; |
||||
int r = m_nodes.find_zero<TXNID, find_by_txnid>(txnid, &n, &idx); |
||||
if (r == DB_NOTFOUND) { |
||||
n = node::alloc(txnid); |
||||
r = m_nodes.insert_at(n, idx); |
||||
invariant_zero(r); |
||||
} |
||||
invariant_notnull(n); |
||||
return n; |
||||
} |
||||
|
||||
wfg::node *wfg::node::alloc(TXNID txnid) { |
||||
node *XCALLOC(n); |
||||
n->txnid = txnid; |
||||
n->visited = false; |
||||
n->edges.create(); |
||||
return n; |
||||
} |
||||
|
||||
void wfg::node::free(wfg::node *n) { |
||||
n->edges.destroy(); |
||||
toku_free(n); |
||||
} |
||||
|
||||
} /* namespace toku */ |
||||
#endif // OS_WIN
|
||||
#endif // ROCKSDB_LITE
|
||||
@ -0,0 +1,123 @@ |
||||
/* -*- mode: C++; c-basic-offset: 4; indent-tabs-mode: nil -*- */ |
||||
// vim: ft=cpp:expandtab:ts=8:sw=4:softtabstop=4:
|
||||
#ident "$Id$" |
||||
/*======
|
||||
This file is part of PerconaFT. |
||||
|
||||
|
||||
Copyright (c) 2006, 2015, Percona and/or its affiliates. All rights reserved. |
||||
|
||||
PerconaFT is free software: you can redistribute it and/or modify |
||||
it under the terms of the GNU General Public License, version 2, |
||||
as published by the Free Software Foundation. |
||||
|
||||
PerconaFT is distributed in the hope that it will be useful, |
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
GNU General Public License for more details. |
||||
|
||||
You should have received a copy of the GNU General Public License |
||||
along with PerconaFT. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
---------------------------------------- |
||||
|
||||
PerconaFT is free software: you can redistribute it and/or modify |
||||
it under the terms of the GNU Affero General Public License, version 3, |
||||
as published by the Free Software Foundation. |
||||
|
||||
PerconaFT is distributed in the hope that it will be useful, |
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
GNU Affero General Public License for more details. |
||||
|
||||
You should have received a copy of the GNU Affero General Public License |
||||
along with PerconaFT. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
---------------------------------------- |
||||
|
||||
Licensed under the Apache License, Version 2.0 (the "License"); |
||||
you may not use this file except in compliance with the License. |
||||
You may obtain a copy of the License at |
||||
|
||||
http://www.apache.org/licenses/LICENSE-2.0
|
||||
|
||||
Unless required by applicable law or agreed to in writing, software |
||||
distributed under the License is distributed on an "AS IS" BASIS, |
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
||||
See the License for the specific language governing permissions and |
||||
======= */ |
||||
|
||||
#ident \ |
||||
"Copyright (c) 2006, 2015, Percona and/or its affiliates. All rights reserved." |
||||
|
||||
#pragma once |
||||
|
||||
#include <functional> |
||||
|
||||
#include "../util/omt.h" |
||||
#include "txnid_set.h" |
||||
|
||||
namespace toku { |
||||
|
||||
// A wfg is a 'wait-for' graph. A directed edge in represents one
|
||||
// txn waiting for another to finish before it can acquire a lock.
|
||||
|
||||
class wfg { |
||||
public: |
||||
// Create a lock request graph
|
||||
void create(void); |
||||
|
||||
// Destroy the internals of the lock request graph
|
||||
void destroy(void); |
||||
|
||||
// Add an edge (a_id, b_id) to the graph
|
||||
void add_edge(TXNID a_txnid, TXNID b_txnid); |
||||
|
||||
// Return true if a node with the given transaction id exists in the graph.
|
||||
// Return false otherwise.
|
||||
bool node_exists(TXNID txnid); |
||||
|
||||
// Return true if there exists a cycle from a given transaction id in the
|
||||
// graph. Return false otherwise.
|
||||
bool cycle_exists_from_txnid(TXNID txnid, |
||||
std::function<void(TXNID)> reporter); |
||||
|
||||
// Apply a given function f to all of the nodes in the graph. The apply
|
||||
// function returns when the function f is called for all of the nodes in the
|
||||
// graph, or the function f returns non-zero.
|
||||
void apply_nodes(int (*fn)(TXNID txnid, void *extra), void *extra); |
||||
|
||||
// Apply a given function f to all of the edges whose origin is a given node
|
||||
// id. The apply function returns when the function f is called for all edges
|
||||
// in the graph rooted at node id, or the function f returns non-zero.
|
||||
void apply_edges(TXNID txnid, |
||||
int (*fn)(TXNID txnid, TXNID edge_txnid, void *extra), |
||||
void *extra); |
||||
|
||||
private: |
||||
struct node { |
||||
// txnid for this node and the associated set of edges
|
||||
TXNID txnid; |
||||
txnid_set edges; |
||||
bool visited; |
||||
|
||||
static node *alloc(TXNID txnid); |
||||
|
||||
static void free(node *n); |
||||
}; |
||||
ENSURE_POD(node); |
||||
|
||||
toku::omt<node *> m_nodes; |
||||
|
||||
node *find_node(TXNID txnid); |
||||
|
||||
node *find_create_node(TXNID txnid); |
||||
|
||||
bool cycle_exists_from_node(node *target, node *head, |
||||
std::function<void(TXNID)> reporter); |
||||
|
||||
static int find_by_txnid(node *const &node_a, const TXNID &txnid_b); |
||||
}; |
||||
ENSURE_POD(wfg); |
||||
|
||||
} /* namespace toku */ |
||||
@ -0,0 +1,201 @@ |
||||
/* -*- mode: C++; c-basic-offset: 4; indent-tabs-mode: nil -*- */ |
||||
// vim: ft=cpp:expandtab:ts=8:sw=4:softtabstop=4:
|
||||
#ident "$Id$" |
||||
/*======
|
||||
This file is part of PerconaFT. |
||||
|
||||
|
||||
Copyright (c) 2006, 2015, Percona and/or its affiliates. All rights reserved. |
||||
|
||||
PerconaFT is free software: you can redistribute it and/or modify |
||||
it under the terms of the GNU General Public License, version 2, |
||||
as published by the Free Software Foundation. |
||||
|
||||
PerconaFT is distributed in the hope that it will be useful, |
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
GNU General Public License for more details. |
||||
|
||||
You should have received a copy of the GNU General Public License |
||||
along with PerconaFT. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
---------------------------------------- |
||||
|
||||
PerconaFT is free software: you can redistribute it and/or modify |
||||
it under the terms of the GNU Affero General Public License, version 3, |
||||
as published by the Free Software Foundation. |
||||
|
||||
PerconaFT is distributed in the hope that it will be useful, |
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
GNU Affero General Public License for more details. |
||||
|
||||
You should have received a copy of the GNU Affero General Public License |
||||
along with PerconaFT. If not, see <http://www.gnu.org/licenses/>.
|
||||
======= */ |
||||
|
||||
#ident \ |
||||
"Copyright (c) 2006, 2015, Percona and/or its affiliates. All rights reserved." |
||||
|
||||
#pragma once |
||||
|
||||
#include <stdlib.h> |
||||
|
||||
#include "toku_portability.h" |
||||
|
||||
/* Percona memory allocation functions and macros.
|
||||
* These are functions for malloc and free */ |
||||
|
||||
int toku_memory_startup(void) __attribute__((constructor)); |
||||
void toku_memory_shutdown(void) __attribute__((destructor)); |
||||
|
||||
/* Generally: errno is set to 0 or a value to indicate problems. */ |
||||
|
||||
// Everything should call toku_malloc() instead of malloc(), and toku_calloc()
|
||||
// instead of calloc() That way the tests can can, e.g., replace the malloc
|
||||
// function using toku_set_func_malloc().
|
||||
void *toku_calloc(size_t nmemb, size_t size) |
||||
__attribute__((__visibility__("default"))); |
||||
void *toku_xcalloc(size_t nmemb, size_t size) |
||||
__attribute__((__visibility__("default"))); |
||||
void *toku_malloc(size_t size) __attribute__((__visibility__("default"))); |
||||
void *toku_malloc_aligned(size_t alignment, size_t size) |
||||
__attribute__((__visibility__("default"))); |
||||
|
||||
// xmalloc aborts instead of return NULL if we run out of memory
|
||||
void *toku_xmalloc(size_t size) __attribute__((__visibility__("default"))); |
||||
void *toku_xrealloc(void *, size_t size) |
||||
__attribute__((__visibility__("default"))); |
||||
void *toku_xmalloc_aligned(size_t alignment, size_t size) |
||||
__attribute__((__visibility__("default"))); |
||||
// Effect: Perform a os_malloc_aligned(size) with the additional property that
|
||||
// the returned pointer is a multiple of ALIGNMENT.
|
||||
// Fail with a resource_assert if the allocation fails (don't return an error
|
||||
// code). If the alloc_aligned function has been set then call it instead.
|
||||
// Requires: alignment is a power of two.
|
||||
|
||||
void toku_free(void *) __attribute__((__visibility__("default"))); |
||||
|
||||
size_t toku_malloc_usable_size(void *p) |
||||
__attribute__((__visibility__("default"))); |
||||
|
||||
/* MALLOC is a macro that helps avoid a common error:
|
||||
* Suppose I write |
||||
* struct foo *x = malloc(sizeof(struct foo)); |
||||
* That works fine. But if I change it to this, I've probably made an mistake: |
||||
* struct foo *x = malloc(sizeof(struct bar)); |
||||
* It can get worse, since one might have something like |
||||
* struct foo *x = malloc(sizeof(struct foo *)) |
||||
* which looks reasonable, but it allocoates enough to hold a pointer instead of |
||||
* the amount needed for the struct. So instead, write struct foo *MALLOC(x); |
||||
* and you cannot go wrong. |
||||
*/ |
||||
#define MALLOC(v) CAST_FROM_VOIDP(v, toku_malloc(sizeof(*v))) |
||||
/* MALLOC_N is like calloc(Except no 0ing of data): It makes an array. Write
|
||||
* int *MALLOC_N(5,x); |
||||
* to make an array of 5 integers. |
||||
*/ |
||||
#define MALLOC_N(n, v) CAST_FROM_VOIDP(v, toku_malloc((n) * sizeof(*v))) |
||||
#define MALLOC_N_ALIGNED(align, n, v) \ |
||||
CAST_FROM_VOIDP(v, toku_malloc_aligned((align), (n) * sizeof(*v))) |
||||
|
||||
// CALLOC_N is like calloc with auto-figuring out size of members
|
||||
#define CALLOC_N(n, v) CAST_FROM_VOIDP(v, toku_calloc((n), sizeof(*v))) |
||||
|
||||
#define CALLOC(v) CALLOC_N(1, v) |
||||
|
||||
// XMALLOC macros are like MALLOC except they abort if the operation fails
|
||||
#define XMALLOC(v) CAST_FROM_VOIDP(v, toku_xmalloc(sizeof(*v))) |
||||
#define XMALLOC_N(n, v) CAST_FROM_VOIDP(v, toku_xmalloc((n) * sizeof(*v))) |
||||
#define XCALLOC_N(n, v) CAST_FROM_VOIDP(v, toku_xcalloc((n), (sizeof(*v)))) |
||||
#define XCALLOC(v) XCALLOC_N(1, v) |
||||
#define XREALLOC(v, s) CAST_FROM_VOIDP(v, toku_xrealloc(v, s)) |
||||
#define XREALLOC_N(n, v) CAST_FROM_VOIDP(v, toku_xrealloc(v, (n) * sizeof(*v))) |
||||
|
||||
#define XMALLOC_N_ALIGNED(align, n, v) \ |
||||
CAST_FROM_VOIDP(v, toku_xmalloc_aligned((align), (n) * sizeof(*v))) |
||||
|
||||
#define XMEMDUP(dst, src) CAST_FROM_VOIDP(dst, toku_xmemdup(src, sizeof(*src))) |
||||
#define XMEMDUP_N(dst, src, len) CAST_FROM_VOIDP(dst, toku_xmemdup(src, len)) |
||||
|
||||
// ZERO_ARRAY writes zeroes to a stack-allocated array
|
||||
#define ZERO_ARRAY(o) \ |
||||
do { \
|
||||
memset((o), 0, sizeof(o)); \
|
||||
} while (0) |
||||
// ZERO_STRUCT writes zeroes to a stack-allocated struct
|
||||
#define ZERO_STRUCT(o) \ |
||||
do { \
|
||||
memset(&(o), 0, sizeof(o)); \
|
||||
} while (0) |
||||
|
||||
/* Copy memory. Analogous to strdup() */ |
||||
void *toku_memdup(const void *v, size_t len); |
||||
/* Toku-version of strdup. Use this so that it calls toku_malloc() */ |
||||
char *toku_strdup(const char *s) __attribute__((__visibility__("default"))); |
||||
/* Toku-version of strndup. Use this so that it calls toku_malloc() */ |
||||
char *toku_strndup(const char *s, size_t n) |
||||
__attribute__((__visibility__("default"))); |
||||
/* Copy memory. Analogous to strdup() Crashes instead of returning NULL */ |
||||
void *toku_xmemdup(const void *v, size_t len) |
||||
__attribute__((__visibility__("default"))); |
||||
/* Toku-version of strdup. Use this so that it calls toku_xmalloc() Crashes
|
||||
* instead of returning NULL */ |
||||
char *toku_xstrdup(const char *s) __attribute__((__visibility__("default"))); |
||||
|
||||
void toku_malloc_cleanup( |
||||
void); /* Before exiting, call this function to free up any internal data
|
||||
structures from toku_malloc. Otherwise valgrind will complain of |
||||
memory leaks. */ |
||||
|
||||
/* Check to see if everything malloc'd was free. Might be a no-op depending on
|
||||
* how memory.c is configured. */ |
||||
void toku_memory_check_all_free(void); |
||||
/* Check to see if memory is "sane". Might be a no-op. Probably better to
|
||||
* simply use valgrind. */ |
||||
void toku_do_memory_check(void); |
||||
|
||||
typedef void *(*malloc_fun_t)(size_t); |
||||
typedef void (*free_fun_t)(void *); |
||||
typedef void *(*realloc_fun_t)(void *, size_t); |
||||
typedef void *(*malloc_aligned_fun_t)(size_t /*alignment*/, size_t /*size*/); |
||||
typedef void *(*realloc_aligned_fun_t)(size_t /*alignment*/, void * /*pointer*/, |
||||
size_t /*size*/); |
||||
|
||||
void toku_set_func_malloc(malloc_fun_t f); |
||||
void toku_set_func_xmalloc_only(malloc_fun_t f); |
||||
void toku_set_func_malloc_only(malloc_fun_t f); |
||||
void toku_set_func_realloc(realloc_fun_t f); |
||||
void toku_set_func_xrealloc_only(realloc_fun_t f); |
||||
void toku_set_func_realloc_only(realloc_fun_t f); |
||||
void toku_set_func_free(free_fun_t f); |
||||
|
||||
typedef struct memory_status { |
||||
uint64_t malloc_count; // number of malloc operations
|
||||
uint64_t free_count; // number of free operations
|
||||
uint64_t realloc_count; // number of realloc operations
|
||||
uint64_t malloc_fail; // number of malloc operations that failed
|
||||
uint64_t realloc_fail; // number of realloc operations that failed
|
||||
uint64_t requested; // number of bytes requested
|
||||
uint64_t used; // number of bytes used (requested + overhead), obtained from
|
||||
// malloc_usable_size()
|
||||
uint64_t freed; // number of bytes freed;
|
||||
uint64_t max_requested_size; // largest attempted allocation size
|
||||
uint64_t last_failed_size; // size of the last failed allocation attempt
|
||||
volatile uint64_t |
||||
max_in_use; // maximum memory footprint (used - freed), approximate (not
|
||||
// worth threadsafety overhead for exact)
|
||||
const char *mallocator_version; |
||||
uint64_t mmap_threshold; |
||||
} LOCAL_MEMORY_STATUS_S, *LOCAL_MEMORY_STATUS; |
||||
|
||||
void toku_memory_get_status(LOCAL_MEMORY_STATUS s); |
||||
|
||||
// Effect: Like toku_memory_footprint, except instead of passing p,
|
||||
// we pass toku_malloc_usable_size(p).
|
||||
size_t toku_memory_footprint_given_usable_size(size_t touched, size_t usable); |
||||
|
||||
// Effect: Return an estimate how how much space an object is using, possibly by
|
||||
// using toku_malloc_usable_size(p).
|
||||
// If p is NULL then returns 0.
|
||||
size_t toku_memory_footprint(void *p, size_t touched); |
||||
@ -0,0 +1,37 @@ |
||||
//
|
||||
// A replacement for toku_assert.h
|
||||
//
|
||||
#pragma once |
||||
|
||||
#include <assert.h> |
||||
#include <errno.h> |
||||
|
||||
#ifdef NDEBUG |
||||
|
||||
#define assert_zero(a) ((void)(a)) |
||||
#define invariant(a) ((void)(a)) |
||||
#define invariant_notnull(a) ((void)(a)) |
||||
#define invariant_zero(a) ((void)(a)) |
||||
|
||||
#else |
||||
|
||||
#define assert_zero(a) assert((a) == 0) |
||||
#define invariant(a) assert(a) |
||||
#define invariant_notnull(a) assert(a) |
||||
#define invariant_zero(a) assert_zero(a) |
||||
|
||||
#endif |
||||
|
||||
#define lazy_assert_zero(a) assert_zero(a) |
||||
|
||||
#define paranoid_invariant_zero(a) assert_zero(a) |
||||
#define paranoid_invariant_notnull(a) assert(a) |
||||
#define paranoid_invariant(a) assert(a) |
||||
|
||||
#define ENSURE_POD(type) \ |
||||
static_assert(std::is_pod<type>::value, #type "isn't POD") |
||||
|
||||
inline int get_error_errno(void) { |
||||
invariant(errno); |
||||
return errno; |
||||
} |
||||
@ -0,0 +1,116 @@ |
||||
/* -*- mode: C++; c-basic-offset: 4; indent-tabs-mode: nil -*- */ |
||||
// vim: ft=cpp:expandtab:ts=8:sw=4:softtabstop=4:
|
||||
#ident "$Id$" |
||||
/*======
|
||||
This file is part of PerconaFT. |
||||
|
||||
|
||||
Copyright (c) 2006, 2015, Percona and/or its affiliates. All rights reserved. |
||||
|
||||
PerconaFT is free software: you can redistribute it and/or modify |
||||
it under the terms of the GNU General Public License, version 2, |
||||
as published by the Free Software Foundation. |
||||
|
||||
PerconaFT is distributed in the hope that it will be useful, |
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
GNU General Public License for more details. |
||||
|
||||
You should have received a copy of the GNU General Public License |
||||
along with PerconaFT. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
---------------------------------------- |
||||
|
||||
PerconaFT is free software: you can redistribute it and/or modify |
||||
it under the terms of the GNU Affero General Public License, version 3, |
||||
as published by the Free Software Foundation. |
||||
|
||||
PerconaFT is distributed in the hope that it will be useful, |
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
GNU Affero General Public License for more details. |
||||
|
||||
You should have received a copy of the GNU Affero General Public License |
||||
along with PerconaFT. If not, see <http://www.gnu.org/licenses/>.
|
||||
======= */ |
||||
|
||||
#ident \ |
||||
"Copyright (c) 2006, 2015, Percona and/or its affiliates. All rights reserved." |
||||
|
||||
#pragma once |
||||
|
||||
// PORT2: #include <portability/toku_config.h>
|
||||
#include <stdbool.h> |
||||
#include <stddef.h> |
||||
#include <stdint.h> |
||||
|
||||
#include "toku_assert_subst.h" |
||||
|
||||
__attribute__((const, always_inline)) static inline intptr_t which_cache_line( |
||||
intptr_t addr) { |
||||
static const size_t assumed_cache_line_size = 64; |
||||
return addr / assumed_cache_line_size; |
||||
} |
||||
template <typename T> |
||||
__attribute__((const, always_inline)) static inline bool crosses_boundary( |
||||
T *addr, size_t width) { |
||||
const intptr_t int_addr = reinterpret_cast<intptr_t>(addr); |
||||
const intptr_t last_byte = int_addr + width - 1; |
||||
return which_cache_line(int_addr) != which_cache_line(last_byte); |
||||
} |
||||
|
||||
template <typename T, typename U> |
||||
__attribute__((always_inline)) static inline T toku_sync_fetch_and_add(T *addr, |
||||
U diff) { |
||||
paranoid_invariant(!crosses_boundary(addr, sizeof *addr)); |
||||
return __sync_fetch_and_add(addr, diff); |
||||
} |
||||
template <typename T, typename U> |
||||
__attribute__((always_inline)) static inline T toku_sync_add_and_fetch(T *addr, |
||||
U diff) { |
||||
paranoid_invariant(!crosses_boundary(addr, sizeof *addr)); |
||||
return __sync_add_and_fetch(addr, diff); |
||||
} |
||||
template <typename T, typename U> |
||||
__attribute__((always_inline)) static inline T toku_sync_fetch_and_sub(T *addr, |
||||
U diff) { |
||||
paranoid_invariant(!crosses_boundary(addr, sizeof *addr)); |
||||
return __sync_fetch_and_sub(addr, diff); |
||||
} |
||||
template <typename T, typename U> |
||||
__attribute__((always_inline)) static inline T toku_sync_sub_and_fetch(T *addr, |
||||
U diff) { |
||||
paranoid_invariant(!crosses_boundary(addr, sizeof *addr)); |
||||
return __sync_sub_and_fetch(addr, diff); |
||||
} |
||||
template <typename T, typename U, typename V> |
||||
__attribute__((always_inline)) static inline T toku_sync_val_compare_and_swap( |
||||
T *addr, U oldval, V newval) { |
||||
paranoid_invariant(!crosses_boundary(addr, sizeof *addr)); |
||||
return __sync_val_compare_and_swap(addr, oldval, newval); |
||||
} |
||||
template <typename T, typename U, typename V> |
||||
__attribute__((always_inline)) static inline bool |
||||
toku_sync_bool_compare_and_swap(T *addr, U oldval, V newval) { |
||||
paranoid_invariant(!crosses_boundary(addr, sizeof *addr)); |
||||
return __sync_bool_compare_and_swap(addr, oldval, newval); |
||||
} |
||||
|
||||
// in case you include this but not toku_portability.h
|
||||
#pragma GCC poison __sync_fetch_and_add |
||||
#pragma GCC poison __sync_fetch_and_sub |
||||
#pragma GCC poison __sync_fetch_and_or |
||||
#pragma GCC poison __sync_fetch_and_and |
||||
#pragma GCC poison __sync_fetch_and_xor |
||||
#pragma GCC poison __sync_fetch_and_nand |
||||
#pragma GCC poison __sync_add_and_fetch |
||||
#pragma GCC poison __sync_sub_and_fetch |
||||
#pragma GCC poison __sync_or_and_fetch |
||||
#pragma GCC poison __sync_and_and_fetch |
||||
#pragma GCC poison __sync_xor_and_fetch |
||||
#pragma GCC poison __sync_nand_and_fetch |
||||
#pragma GCC poison __sync_bool_compare_and_swap |
||||
#pragma GCC poison __sync_val_compare_and_swap |
||||
#pragma GCC poison __sync_synchronize |
||||
#pragma GCC poison __sync_lock_test_and_set |
||||
#pragma GCC poison __sync_release |
||||
@ -0,0 +1,82 @@ |
||||
/*
|
||||
A wrapper around rocksdb::TransactionDBMutexFactory-provided condition and |
||||
mutex that provides toku_pthread_*-like interface. The functions are named |
||||
|
||||
toku_external_{mutex|cond}_XXX |
||||
|
||||
Lock Tree uses this mutex and condition for interruptible (long) lock waits. |
||||
|
||||
(It also still uses toku_pthread_XXX calls for mutexes/conditions for |
||||
shorter waits on internal objects) |
||||
*/ |
||||
|
||||
#pragma once |
||||
|
||||
#include <pthread.h> |
||||
#include <stdint.h> |
||||
#include <time.h> |
||||
|
||||
#include "rocksdb/utilities/transaction_db.h" |
||||
#include "rocksdb/utilities/transaction_db_mutex.h" |
||||
#include "toku_portability.h" |
||||
|
||||
using ROCKSDB_NAMESPACE::TransactionDBCondVar; |
||||
using ROCKSDB_NAMESPACE::TransactionDBMutex; |
||||
|
||||
typedef std::shared_ptr<ROCKSDB_NAMESPACE::TransactionDBMutexFactory> |
||||
toku_external_mutex_factory_t; |
||||
|
||||
typedef std::shared_ptr<TransactionDBMutex> toku_external_mutex_t; |
||||
typedef std::shared_ptr<TransactionDBCondVar> toku_external_cond_t; |
||||
|
||||
static inline void toku_external_cond_init( |
||||
toku_external_mutex_factory_t mutex_factory, toku_external_cond_t *cond) { |
||||
*cond = mutex_factory->AllocateCondVar(); |
||||
} |
||||
|
||||
inline void toku_external_cond_destroy(toku_external_cond_t *cond) { |
||||
cond->reset(); // this will destroy the managed object
|
||||
} |
||||
|
||||
inline void toku_external_cond_signal(toku_external_cond_t *cond) { |
||||
(*cond)->Notify(); |
||||
} |
||||
|
||||
inline void toku_external_cond_broadcast(toku_external_cond_t *cond) { |
||||
(*cond)->NotifyAll(); |
||||
} |
||||
|
||||
inline int toku_external_cond_timedwait(toku_external_cond_t *cond, |
||||
toku_external_mutex_t *mutex, |
||||
int64_t timeout_microsec) { |
||||
auto res = (*cond)->WaitFor(*mutex, timeout_microsec); |
||||
if (res.ok()) |
||||
return 0; |
||||
else |
||||
return ETIMEDOUT; |
||||
} |
||||
|
||||
inline void toku_external_mutex_init(toku_external_mutex_factory_t factory, |
||||
toku_external_mutex_t *mutex) { |
||||
// Use placement new: the memory has been allocated but constructor wasn't
|
||||
// called
|
||||
new (mutex) toku_external_mutex_t; |
||||
*mutex = factory->AllocateMutex(); |
||||
} |
||||
|
||||
inline void toku_external_mutex_lock(toku_external_mutex_t *mutex) { |
||||
(*mutex)->Lock(); |
||||
} |
||||
|
||||
inline int toku_external_mutex_trylock(toku_external_mutex_t *mutex) { |
||||
(*mutex)->Lock(); |
||||
return 0; |
||||
} |
||||
|
||||
inline void toku_external_mutex_unlock(toku_external_mutex_t *mutex) { |
||||
(*mutex)->UnLock(); |
||||
} |
||||
|
||||
inline void toku_external_mutex_destroy(toku_external_mutex_t *mutex) { |
||||
mutex->reset(); // this will destroy the managed object
|
||||
} |
||||
@ -0,0 +1,240 @@ |
||||
#pragma once |
||||
|
||||
#include <stdio.h> // FILE |
||||
|
||||
// Performance instrumentation object identifier type
|
||||
typedef unsigned int pfs_key_t; |
||||
|
||||
enum class toku_instr_object_type { mutex, rwlock, cond, thread, file }; |
||||
|
||||
struct PSI_file; |
||||
|
||||
struct TOKU_FILE { |
||||
/** The real file. */ |
||||
FILE *file; |
||||
struct PSI_file *key; |
||||
TOKU_FILE() : file(nullptr), key(nullptr) {} |
||||
}; |
||||
|
||||
struct PSI_mutex; |
||||
struct PSI_cond; |
||||
struct PSI_rwlock; |
||||
|
||||
struct toku_mutex_t; |
||||
struct toku_cond_t; |
||||
struct toku_pthread_rwlock_t; |
||||
|
||||
class toku_instr_key; |
||||
|
||||
class toku_instr_probe_empty { |
||||
public: |
||||
explicit toku_instr_probe_empty(UU(const toku_instr_key &key)) {} |
||||
|
||||
void start_with_source_location(UU(const char *src_file), UU(int src_line)) {} |
||||
|
||||
void stop() {} |
||||
}; |
||||
|
||||
#define TOKU_PROBE_START(p) p->start_with_source_location(__FILE__, __LINE__) |
||||
#define TOKU_PROBE_STOP(p) p->stop |
||||
|
||||
extern toku_instr_key toku_uninstrumented; |
||||
|
||||
#ifndef MYSQL_TOKUDB_ENGINE |
||||
|
||||
#include <pthread.h> |
||||
|
||||
class toku_instr_key { |
||||
public: |
||||
toku_instr_key(UU(toku_instr_object_type type), UU(const char *group), |
||||
UU(const char *name)) {} |
||||
|
||||
explicit toku_instr_key(UU(pfs_key_t key_id)) {} |
||||
// No-instrumentation constructor:
|
||||
toku_instr_key() {} |
||||
~toku_instr_key() {} |
||||
}; |
||||
|
||||
typedef toku_instr_probe_empty toku_instr_probe; |
||||
|
||||
enum class toku_instr_file_op { |
||||
file_stream_open, |
||||
file_create, |
||||
file_open, |
||||
file_delete, |
||||
file_rename, |
||||
file_read, |
||||
file_write, |
||||
file_sync, |
||||
file_stream_close, |
||||
file_close, |
||||
file_stat |
||||
}; |
||||
|
||||
struct PSI_file {}; |
||||
struct PSI_mutex {}; |
||||
|
||||
struct toku_io_instrumentation {}; |
||||
|
||||
inline int toku_pthread_create(UU(const toku_instr_key &key), pthread_t *thread, |
||||
const pthread_attr_t *attr, |
||||
void *(*start_routine)(void *), void *arg) { |
||||
return pthread_create(thread, attr, start_routine, arg); |
||||
} |
||||
|
||||
inline void toku_instr_register_current_thread() {} |
||||
|
||||
inline void toku_instr_delete_current_thread() {} |
||||
|
||||
// Instrument file creation, opening, closing, and renaming
|
||||
inline void toku_instr_file_open_begin(UU(toku_io_instrumentation &io_instr), |
||||
UU(const toku_instr_key &key), |
||||
UU(toku_instr_file_op op), |
||||
UU(const char *name), |
||||
UU(const char *src_file), |
||||
UU(int src_line)) {} |
||||
|
||||
inline void toku_instr_file_stream_open_end( |
||||
UU(toku_io_instrumentation &io_instr), UU(TOKU_FILE &file)) {} |
||||
|
||||
inline void toku_instr_file_open_end(UU(toku_io_instrumentation &io_instr), |
||||
UU(int fd)) {} |
||||
|
||||
inline void toku_instr_file_name_close_begin( |
||||
UU(toku_io_instrumentation &io_instr), UU(const toku_instr_key &key), |
||||
UU(toku_instr_file_op op), UU(const char *name), UU(const char *src_file), |
||||
UU(int src_line)) {} |
||||
|
||||
inline void toku_instr_file_stream_close_begin( |
||||
UU(toku_io_instrumentation &io_instr), UU(toku_instr_file_op op), |
||||
UU(TOKU_FILE &file), UU(const char *src_file), UU(int src_line)) {} |
||||
|
||||
inline void toku_instr_file_fd_close_begin( |
||||
UU(toku_io_instrumentation &io_instr), UU(toku_instr_file_op op), |
||||
UU(int fd), UU(const char *src_file), UU(int src_line)) {} |
||||
|
||||
inline void toku_instr_file_close_end(UU(toku_io_instrumentation &io_instr), |
||||
UU(int result)) {} |
||||
|
||||
inline void toku_instr_file_io_begin(UU(toku_io_instrumentation &io_instr), |
||||
UU(toku_instr_file_op op), UU(int fd), |
||||
UU(unsigned int count), |
||||
UU(const char *src_file), |
||||
UU(int src_line)) {} |
||||
|
||||
inline void toku_instr_file_name_io_begin( |
||||
UU(toku_io_instrumentation &io_instr), UU(const toku_instr_key &key), |
||||
UU(toku_instr_file_op op), UU(const char *name), UU(unsigned int count), |
||||
UU(const char *src_file), UU(int src_line)) {} |
||||
|
||||
inline void toku_instr_file_stream_io_begin( |
||||
UU(toku_io_instrumentation &io_instr), UU(toku_instr_file_op op), |
||||
UU(TOKU_FILE &file), UU(unsigned int count), UU(const char *src_file), |
||||
UU(int src_line)) {} |
||||
|
||||
inline void toku_instr_file_io_end(UU(toku_io_instrumentation &io_instr), |
||||
UU(unsigned int count)) {} |
||||
|
||||
struct toku_mutex_t; |
||||
|
||||
struct toku_mutex_instrumentation {}; |
||||
|
||||
inline PSI_mutex *toku_instr_mutex_init(UU(const toku_instr_key &key), |
||||
UU(toku_mutex_t &mutex)) { |
||||
return nullptr; |
||||
} |
||||
|
||||
inline void toku_instr_mutex_destroy(UU(PSI_mutex *&mutex_instr)) {} |
||||
|
||||
inline void toku_instr_mutex_lock_start( |
||||
UU(toku_mutex_instrumentation &mutex_instr), UU(toku_mutex_t &mutex), |
||||
UU(const char *src_file), UU(int src_line)) {} |
||||
|
||||
inline void toku_instr_mutex_trylock_start( |
||||
UU(toku_mutex_instrumentation &mutex_instr), UU(toku_mutex_t &mutex), |
||||
UU(const char *src_file), UU(int src_line)) {} |
||||
|
||||
inline void toku_instr_mutex_lock_end( |
||||
UU(toku_mutex_instrumentation &mutex_instr), |
||||
UU(int pthread_mutex_lock_result)) {} |
||||
|
||||
inline void toku_instr_mutex_unlock(UU(PSI_mutex *mutex_instr)) {} |
||||
|
||||
struct toku_cond_instrumentation {}; |
||||
|
||||
enum class toku_instr_cond_op { |
||||
cond_wait, |
||||
cond_timedwait, |
||||
}; |
||||
|
||||
inline PSI_cond *toku_instr_cond_init(UU(const toku_instr_key &key), |
||||
UU(toku_cond_t &cond)) { |
||||
return nullptr; |
||||
} |
||||
|
||||
inline void toku_instr_cond_destroy(UU(PSI_cond *&cond_instr)) {} |
||||
|
||||
inline void toku_instr_cond_wait_start( |
||||
UU(toku_cond_instrumentation &cond_instr), UU(toku_instr_cond_op op), |
||||
UU(toku_cond_t &cond), UU(toku_mutex_t &mutex), UU(const char *src_file), |
||||
UU(int src_line)) {} |
||||
|
||||
inline void toku_instr_cond_wait_end(UU(toku_cond_instrumentation &cond_instr), |
||||
UU(int pthread_cond_wait_result)) {} |
||||
|
||||
inline void toku_instr_cond_signal(UU(toku_cond_t &cond)) {} |
||||
|
||||
inline void toku_instr_cond_broadcast(UU(toku_cond_t &cond)) {} |
||||
|
||||
#if 0 |
||||
// rw locks are not used
|
||||
// rwlock instrumentation
|
||||
struct toku_rwlock_instrumentation {}; |
||||
|
||||
inline PSI_rwlock *toku_instr_rwlock_init(UU(const toku_instr_key &key), |
||||
UU(toku_pthread_rwlock_t &rwlock)) { |
||||
return nullptr; |
||||
} |
||||
|
||||
inline void toku_instr_rwlock_destroy(UU(PSI_rwlock *&rwlock_instr)) {} |
||||
|
||||
inline void toku_instr_rwlock_rdlock_wait_start( |
||||
UU(toku_rwlock_instrumentation &rwlock_instr), |
||||
UU(toku_pthread_rwlock_t &rwlock), |
||||
UU(const char *src_file), |
||||
UU(int src_line)) {} |
||||
|
||||
inline void toku_instr_rwlock_wrlock_wait_start( |
||||
UU(toku_rwlock_instrumentation &rwlock_instr), |
||||
UU(toku_pthread_rwlock_t &rwlock), |
||||
UU(const char *src_file), |
||||
UU(int src_line)) {} |
||||
|
||||
inline void toku_instr_rwlock_rdlock_wait_end( |
||||
UU(toku_rwlock_instrumentation &rwlock_instr), |
||||
UU(int pthread_rwlock_wait_result)) {} |
||||
|
||||
inline void toku_instr_rwlock_wrlock_wait_end( |
||||
UU(toku_rwlock_instrumentation &rwlock_instr), |
||||
UU(int pthread_rwlock_wait_result)) {} |
||||
|
||||
inline void toku_instr_rwlock_unlock(UU(toku_pthread_rwlock_t &rwlock)) {} |
||||
#endif |
||||
|
||||
#else // MYSQL_TOKUDB_ENGINE
|
||||
// There can be not only mysql but also mongodb or any other PFS stuff
|
||||
#include <toku_instr_mysql.h> |
||||
#endif // MYSQL_TOKUDB_ENGINE
|
||||
|
||||
// Mutexes
|
||||
extern toku_instr_key manager_escalation_mutex_key; |
||||
extern toku_instr_key manager_escalator_mutex_key; |
||||
extern toku_instr_key manager_mutex_key; |
||||
extern toku_instr_key treenode_mutex_key; |
||||
extern toku_instr_key locktree_request_info_mutex_key; |
||||
extern toku_instr_key locktree_request_info_retry_mutex_key; |
||||
|
||||
// condition vars
|
||||
extern toku_instr_key lock_request_m_wait_cond_key; |
||||
extern toku_instr_key locktree_request_info_retry_cv_key; |
||||
extern toku_instr_key manager_m_escalator_done_key; // unused
|
||||
@ -0,0 +1,73 @@ |
||||
/* -*- mode: C++; c-basic-offset: 4; indent-tabs-mode: nil -*- */ |
||||
// vim: ft=cpp:expandtab:ts=8:sw=4:softtabstop=4:
|
||||
#ident "$Id$" |
||||
/*======
|
||||
This file is part of PerconaFT. |
||||
|
||||
|
||||
Copyright (c) 2006, 2015, Percona and/or its affiliates. All rights reserved. |
||||
|
||||
PerconaFT is free software: you can redistribute it and/or modify |
||||
it under the terms of the GNU General Public License, version 2, |
||||
as published by the Free Software Foundation. |
||||
|
||||
PerconaFT is distributed in the hope that it will be useful, |
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
GNU General Public License for more details. |
||||
|
||||
You should have received a copy of the GNU General Public License |
||||
along with PerconaFT. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
---------------------------------------- |
||||
|
||||
PerconaFT is free software: you can redistribute it and/or modify |
||||
it under the terms of the GNU Affero General Public License, version 3, |
||||
as published by the Free Software Foundation. |
||||
|
||||
PerconaFT is distributed in the hope that it will be useful, |
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
GNU Affero General Public License for more details. |
||||
|
||||
You should have received a copy of the GNU Affero General Public License |
||||
along with PerconaFT. If not, see <http://www.gnu.org/licenses/>.
|
||||
======= */ |
||||
|
||||
#ident \ |
||||
"Copyright (c) 2006, 2015, Percona and/or its affiliates. All rights reserved." |
||||
|
||||
#pragma once |
||||
|
||||
#if defined(__clang__) |
||||
#define constexpr_static_assert(a, b) |
||||
#else |
||||
#define constexpr_static_assert(a, b) static_assert(a, b) |
||||
#endif |
||||
|
||||
// include here, before they get deprecated
|
||||
#include <inttypes.h> |
||||
#include <stdint.h> |
||||
#include <stdio.h> |
||||
#include <sys/stat.h> |
||||
#include <sys/time.h> |
||||
#include <sys/types.h> |
||||
#include <unistd.h> |
||||
|
||||
#include "toku_atomic.h" |
||||
|
||||
#if defined(__cplusplus) |
||||
#include <type_traits> |
||||
#endif |
||||
|
||||
#if defined(__cplusplus) |
||||
// decltype() here gives a reference-to-pointer instead of just a pointer,
|
||||
// just use __typeof__
|
||||
#define CAST_FROM_VOIDP(name, value) name = static_cast<__typeof__(name)>(value) |
||||
#else |
||||
#define CAST_FROM_VOIDP(name, value) name = cast_to_typeof(name)(value) |
||||
#endif |
||||
|
||||
#define UU(x) x __attribute__((__unused__)) |
||||
|
||||
#include "toku_instrumentation.h" |
||||
@ -0,0 +1,501 @@ |
||||
/* -*- mode: C++; c-basic-offset: 4; indent-tabs-mode: nil -*- */ |
||||
// vim: ft=cpp:expandtab:ts=8:sw=4:softtabstop=4:
|
||||
#ident "$Id$" |
||||
/*======
|
||||
This file is part of PerconaFT. |
||||
|
||||
|
||||
Copyright (c) 2006, 2015, Percona and/or its affiliates. All rights reserved. |
||||
|
||||
PerconaFT is free software: you can redistribute it and/or modify |
||||
it under the terms of the GNU General Public License, version 2, |
||||
as published by the Free Software Foundation. |
||||
|
||||
PerconaFT is distributed in the hope that it will be useful, |
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
GNU General Public License for more details. |
||||
|
||||
You should have received a copy of the GNU General Public License |
||||
along with PerconaFT. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
---------------------------------------- |
||||
|
||||
PerconaFT is free software: you can redistribute it and/or modify |
||||
it under the terms of the GNU Affero General Public License, version 3, |
||||
as published by the Free Software Foundation. |
||||
|
||||
PerconaFT is distributed in the hope that it will be useful, |
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
GNU Affero General Public License for more details. |
||||
|
||||
You should have received a copy of the GNU Affero General Public License |
||||
along with PerconaFT. If not, see <http://www.gnu.org/licenses/>.
|
||||
======= */ |
||||
|
||||
#ident \ |
||||
"Copyright (c) 2006, 2015, Percona and/or its affiliates. All rights reserved." |
||||
|
||||
#pragma once |
||||
|
||||
#include <pthread.h> |
||||
#include <stdint.h> |
||||
#include <time.h> |
||||
|
||||
#include "toku_portability.h" |
||||
// PORT2: #include "toku_assert.h"
|
||||
|
||||
// TODO: some things moved toku_instrumentation.h, not necessarily the best
|
||||
// place
|
||||
typedef pthread_attr_t toku_pthread_attr_t; |
||||
typedef pthread_t toku_pthread_t; |
||||
typedef pthread_mutex_t toku_pthread_mutex_t; |
||||
typedef pthread_condattr_t toku_pthread_condattr_t; |
||||
typedef pthread_cond_t toku_pthread_cond_t; |
||||
typedef pthread_rwlockattr_t toku_pthread_rwlockattr_t; |
||||
typedef pthread_key_t toku_pthread_key_t; |
||||
typedef struct timespec toku_timespec_t; |
||||
|
||||
// TODO: break this include loop
|
||||
#include <pthread.h> |
||||
typedef pthread_mutexattr_t toku_pthread_mutexattr_t; |
||||
|
||||
struct toku_mutex_t { |
||||
pthread_mutex_t pmutex; |
||||
struct PSI_mutex *psi_mutex; /* The performance schema instrumentation hook */ |
||||
#if defined(TOKU_PTHREAD_DEBUG) |
||||
pthread_t owner; // = pthread_self(); // for debugging
|
||||
bool locked; |
||||
bool valid; |
||||
pfs_key_t instr_key_id; |
||||
#endif // defined(TOKU_PTHREAD_DEBUG)
|
||||
}; |
||||
|
||||
struct toku_cond_t { |
||||
pthread_cond_t pcond; |
||||
struct PSI_cond *psi_cond; |
||||
#if defined(TOKU_PTHREAD_DEBUG) |
||||
pfs_key_t instr_key_id; |
||||
#endif // defined(TOKU_PTHREAD_DEBUG)
|
||||
}; |
||||
|
||||
#if defined(TOKU_PTHREAD_DEBUG) |
||||
#define TOKU_COND_INITIALIZER \ |
||||
{ .pcond = PTHREAD_COND_INITIALIZER, .psi_cond = nullptr, .instr_key_id = 0 } |
||||
#else |
||||
#define TOKU_COND_INITIALIZER \ |
||||
{ .pcond = PTHREAD_COND_INITIALIZER, .psi_cond = nullptr } |
||||
#endif // defined(TOKU_PTHREAD_DEBUG)
|
||||
|
||||
struct toku_pthread_rwlock_t { |
||||
pthread_rwlock_t rwlock; |
||||
struct PSI_rwlock *psi_rwlock; |
||||
#if defined(TOKU_PTHREAD_DEBUG) |
||||
pfs_key_t instr_key_id; |
||||
#endif // defined(TOKU_PTHREAD_DEBUG)
|
||||
}; |
||||
|
||||
typedef struct toku_mutex_aligned { |
||||
toku_mutex_t aligned_mutex __attribute__((__aligned__(64))); |
||||
} toku_mutex_aligned_t; |
||||
|
||||
// Initializing with {} will fill in a struct with all zeros.
|
||||
// But you may also need a pragma to suppress the warnings, as follows
|
||||
//
|
||||
// #pragma GCC diagnostic push
|
||||
// #pragma GCC diagnostic ignored "-Wmissing-field-initializers"
|
||||
// toku_mutex_t foo = ZERO_MUTEX_INITIALIZER;
|
||||
// #pragma GCC diagnostic pop
|
||||
//
|
||||
// In general it will be a lot of busy work to make this codebase compile
|
||||
// cleanly with -Wmissing-field-initializers
|
||||
|
||||
#define ZERO_MUTEX_INITIALIZER \ |
||||
{} |
||||
|
||||
#if defined(TOKU_PTHREAD_DEBUG) |
||||
#define TOKU_MUTEX_INITIALIZER \ |
||||
{ \
|
||||
.pmutex = PTHREAD_MUTEX_INITIALIZER, .psi_mutex = nullptr, .owner = 0, \
|
||||
.locked = false, .valid = true, .instr_key_id = 0 \
|
||||
} |
||||
#else |
||||
#define TOKU_MUTEX_INITIALIZER \ |
||||
{ .pmutex = PTHREAD_MUTEX_INITIALIZER, .psi_mutex = nullptr } |
||||
#endif // defined(TOKU_PTHREAD_DEBUG)
|
||||
|
||||
// Darwin doesn't provide adaptive mutexes
|
||||
#if defined(__APPLE__) |
||||
#define TOKU_MUTEX_ADAPTIVE PTHREAD_MUTEX_DEFAULT |
||||
#if defined(TOKU_PTHREAD_DEBUG) |
||||
#define TOKU_ADAPTIVE_MUTEX_INITIALIZER \ |
||||
{ \
|
||||
.pmutex = PTHREAD_MUTEX_INITIALIZER, .psi_mutex = nullptr, .owner = 0, \
|
||||
.locked = false, .valid = true, .instr_key_id = 0 \
|
||||
} |
||||
#else |
||||
#define TOKU_ADAPTIVE_MUTEX_INITIALIZER \ |
||||
{ .pmutex = PTHREAD_MUTEX_INITIALIZER, .psi_mutex = nullptr } |
||||
#endif // defined(TOKU_PTHREAD_DEBUG)
|
||||
#else // __FreeBSD__, __linux__, at least
|
||||
#define TOKU_MUTEX_ADAPTIVE PTHREAD_MUTEX_ADAPTIVE_NP |
||||
#if defined(TOKU_PTHREAD_DEBUG) |
||||
#define TOKU_ADAPTIVE_MUTEX_INITIALIZER \ |
||||
{ \
|
||||
.pmutex = PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP, .psi_mutex = nullptr, \
|
||||
.owner = 0, .locked = false, .valid = true, .instr_key_id = 0 \
|
||||
} |
||||
#else |
||||
#define TOKU_ADAPTIVE_MUTEX_INITIALIZER \ |
||||
{ .pmutex = PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP, .psi_mutex = nullptr } |
||||
#endif // defined(TOKU_PTHREAD_DEBUG)
|
||||
#endif // defined(__APPLE__)
|
||||
|
||||
// Different OSes implement mutexes as different amounts of nested structs.
|
||||
// C++ will fill out all missing values with zeroes if you provide at least one
|
||||
// zero, but it needs the right amount of nesting.
|
||||
#if defined(__FreeBSD__) |
||||
#define ZERO_COND_INITIALIZER \ |
||||
{ 0 } |
||||
#elif defined(__APPLE__) |
||||
#define ZERO_COND_INITIALIZER \ |
||||
{ \
|
||||
{ 0 } \
|
||||
} |
||||
#else // __linux__, at least
|
||||
#define ZERO_COND_INITIALIZER \ |
||||
{} |
||||
#endif |
||||
|
||||
static inline void toku_mutexattr_init(toku_pthread_mutexattr_t *attr) { |
||||
int r = pthread_mutexattr_init(attr); |
||||
assert_zero(r); |
||||
} |
||||
|
||||
static inline void toku_mutexattr_settype(toku_pthread_mutexattr_t *attr, |
||||
int type) { |
||||
int r = pthread_mutexattr_settype(attr, type); |
||||
assert_zero(r); |
||||
} |
||||
|
||||
static inline void toku_mutexattr_destroy(toku_pthread_mutexattr_t *attr) { |
||||
int r = pthread_mutexattr_destroy(attr); |
||||
assert_zero(r); |
||||
} |
||||
|
||||
#if defined(TOKU_PTHREAD_DEBUG) |
||||
static inline void toku_mutex_assert_locked(const toku_mutex_t *mutex) { |
||||
invariant(mutex->locked); |
||||
invariant(mutex->owner == pthread_self()); |
||||
} |
||||
#else |
||||
static inline void toku_mutex_assert_locked(const toku_mutex_t *mutex |
||||
__attribute__((unused))) {} |
||||
#endif // defined(TOKU_PTHREAD_DEBUG)
|
||||
|
||||
// asserting that a mutex is unlocked only makes sense
|
||||
// if the calling thread can guaruntee that no other threads
|
||||
// are trying to lock this mutex at the time of the assertion
|
||||
//
|
||||
// a good example of this is a tree with mutexes on each node.
|
||||
// when a node is locked the caller knows that no other threads
|
||||
// can be trying to lock its childrens' mutexes. the children
|
||||
// are in one of two fixed states: locked or unlocked.
|
||||
#if defined(TOKU_PTHREAD_DEBUG) |
||||
static inline void toku_mutex_assert_unlocked(toku_mutex_t *mutex) { |
||||
invariant(mutex->owner == 0); |
||||
invariant(!mutex->locked); |
||||
} |
||||
#else |
||||
static inline void toku_mutex_assert_unlocked(toku_mutex_t *mutex |
||||
__attribute__((unused))) {} |
||||
#endif // defined(TOKU_PTHREAD_DEBUG)
|
||||
|
||||
#define toku_mutex_lock(M) \ |
||||
toku_mutex_lock_with_source_location(M, __FILE__, __LINE__) |
||||
|
||||
static inline void toku_cond_init(toku_cond_t *cond, |
||||
const toku_pthread_condattr_t *attr) { |
||||
int r = pthread_cond_init(&cond->pcond, attr); |
||||
assert_zero(r); |
||||
} |
||||
|
||||
#define toku_mutex_trylock(M) \ |
||||
toku_mutex_trylock_with_source_location(M, __FILE__, __LINE__) |
||||
|
||||
inline void toku_mutex_unlock(toku_mutex_t *mutex) { |
||||
#if defined(TOKU_PTHREAD_DEBUG) |
||||
invariant(mutex->owner == pthread_self()); |
||||
invariant(mutex->valid); |
||||
invariant(mutex->locked); |
||||
mutex->locked = false; |
||||
mutex->owner = 0; |
||||
#endif // defined(TOKU_PTHREAD_DEBUG)
|
||||
toku_instr_mutex_unlock(mutex->psi_mutex); |
||||
int r = pthread_mutex_unlock(&mutex->pmutex); |
||||
assert_zero(r); |
||||
} |
||||
|
||||
inline void toku_mutex_lock_with_source_location(toku_mutex_t *mutex, |
||||
const char *src_file, |
||||
int src_line) { |
||||
toku_mutex_instrumentation mutex_instr; |
||||
toku_instr_mutex_lock_start(mutex_instr, *mutex, src_file, src_line); |
||||
|
||||
const int r = pthread_mutex_lock(&mutex->pmutex); |
||||
toku_instr_mutex_lock_end(mutex_instr, r); |
||||
|
||||
assert_zero(r); |
||||
#if defined(TOKU_PTHREAD_DEBUG) |
||||
invariant(mutex->valid); |
||||
invariant(!mutex->locked); |
||||
invariant(mutex->owner == 0); |
||||
mutex->locked = true; |
||||
mutex->owner = pthread_self(); |
||||
#endif // defined(TOKU_PTHREAD_DEBUG)
|
||||
} |
||||
|
||||
inline int toku_mutex_trylock_with_source_location(toku_mutex_t *mutex, |
||||
const char *src_file, |
||||
int src_line) { |
||||
toku_mutex_instrumentation mutex_instr; |
||||
toku_instr_mutex_trylock_start(mutex_instr, *mutex, src_file, src_line); |
||||
|
||||
const int r = pthread_mutex_lock(&mutex->pmutex); |
||||
toku_instr_mutex_lock_end(mutex_instr, r); |
||||
|
||||
#if defined(TOKU_PTHREAD_DEBUG) |
||||
if (r == 0) { |
||||
invariant(mutex->valid); |
||||
invariant(!mutex->locked); |
||||
invariant(mutex->owner == 0); |
||||
mutex->locked = true; |
||||
mutex->owner = pthread_self(); |
||||
} |
||||
#endif // defined(TOKU_PTHREAD_DEBUG)
|
||||
return r; |
||||
} |
||||
|
||||
#define toku_cond_wait(C, M) \ |
||||
toku_cond_wait_with_source_location(C, M, __FILE__, __LINE__) |
||||
|
||||
#define toku_cond_timedwait(C, M, W) \ |
||||
toku_cond_timedwait_with_source_location(C, M, W, __FILE__, __LINE__) |
||||
|
||||
inline void toku_cond_init(const toku_instr_key &key, toku_cond_t *cond, |
||||
const pthread_condattr_t *attr) { |
||||
toku_instr_cond_init(key, *cond); |
||||
int r = pthread_cond_init(&cond->pcond, attr); |
||||
assert_zero(r); |
||||
} |
||||
|
||||
inline void toku_cond_destroy(toku_cond_t *cond) { |
||||
toku_instr_cond_destroy(cond->psi_cond); |
||||
int r = pthread_cond_destroy(&cond->pcond); |
||||
assert_zero(r); |
||||
} |
||||
|
||||
inline void toku_cond_wait_with_source_location(toku_cond_t *cond, |
||||
toku_mutex_t *mutex, |
||||
const char *src_file, |
||||
int src_line) { |
||||
#if defined(TOKU_PTHREAD_DEBUG) |
||||
invariant(mutex->locked); |
||||
mutex->locked = false; |
||||
mutex->owner = 0; |
||||
#endif // defined(TOKU_PTHREAD_DEBUG)
|
||||
|
||||
/* Instrumentation start */ |
||||
toku_cond_instrumentation cond_instr; |
||||
toku_instr_cond_wait_start(cond_instr, toku_instr_cond_op::cond_wait, *cond, |
||||
*mutex, src_file, src_line); |
||||
|
||||
/* Instrumented code */ |
||||
const int r = pthread_cond_wait(&cond->pcond, &mutex->pmutex); |
||||
|
||||
/* Instrumentation end */ |
||||
toku_instr_cond_wait_end(cond_instr, r); |
||||
|
||||
assert_zero(r); |
||||
#if defined(TOKU_PTHREAD_DEBUG) |
||||
invariant(!mutex->locked); |
||||
mutex->locked = true; |
||||
mutex->owner = pthread_self(); |
||||
#endif // defined(TOKU_PTHREAD_DEBUG)
|
||||
} |
||||
|
||||
inline int toku_cond_timedwait_with_source_location(toku_cond_t *cond, |
||||
toku_mutex_t *mutex, |
||||
toku_timespec_t *wakeup_at, |
||||
const char *src_file, |
||||
int src_line) { |
||||
#if defined(TOKU_PTHREAD_DEBUG) |
||||
invariant(mutex->locked); |
||||
mutex->locked = false; |
||||
mutex->owner = 0; |
||||
#endif // defined(TOKU_PTHREAD_DEBUG)
|
||||
|
||||
/* Instrumentation start */ |
||||
toku_cond_instrumentation cond_instr; |
||||
toku_instr_cond_wait_start(cond_instr, toku_instr_cond_op::cond_timedwait, |
||||
*cond, *mutex, src_file, src_line); |
||||
|
||||
/* Instrumented code */ |
||||
const int r = pthread_cond_timedwait(&cond->pcond, &mutex->pmutex, wakeup_at); |
||||
|
||||
/* Instrumentation end */ |
||||
toku_instr_cond_wait_end(cond_instr, r); |
||||
|
||||
#if defined(TOKU_PTHREAD_DEBUG) |
||||
invariant(!mutex->locked); |
||||
mutex->locked = true; |
||||
mutex->owner = pthread_self(); |
||||
#endif // defined(TOKU_PTHREAD_DEBUG)
|
||||
return r; |
||||
} |
||||
|
||||
inline void toku_cond_signal(toku_cond_t *cond) { |
||||
toku_instr_cond_signal(*cond); |
||||
const int r = pthread_cond_signal(&cond->pcond); |
||||
assert_zero(r); |
||||
} |
||||
|
||||
inline void toku_cond_broadcast(toku_cond_t *cond) { |
||||
toku_instr_cond_broadcast(*cond); |
||||
const int r = pthread_cond_broadcast(&cond->pcond); |
||||
assert_zero(r); |
||||
} |
||||
|
||||
inline void toku_mutex_init(const toku_instr_key &key, toku_mutex_t *mutex, |
||||
const toku_pthread_mutexattr_t *attr) { |
||||
#if defined(TOKU_PTHREAD_DEBUG) |
||||
mutex->valid = true; |
||||
#endif // defined(TOKU_PTHREAD_DEBUG)
|
||||
toku_instr_mutex_init(key, *mutex); |
||||
const int r = pthread_mutex_init(&mutex->pmutex, attr); |
||||
assert_zero(r); |
||||
#if defined(TOKU_PTHREAD_DEBUG) |
||||
mutex->locked = false; |
||||
invariant(mutex->valid); |
||||
mutex->valid = true; |
||||
mutex->owner = 0; |
||||
#endif // defined(TOKU_PTHREAD_DEBUG)
|
||||
} |
||||
|
||||
inline void toku_mutex_destroy(toku_mutex_t *mutex) { |
||||
#if defined(TOKU_PTHREAD_DEBUG) |
||||
invariant(mutex->valid); |
||||
mutex->valid = false; |
||||
invariant(!mutex->locked); |
||||
#endif // defined(TOKU_PTHREAD_DEBUG)
|
||||
toku_instr_mutex_destroy(mutex->psi_mutex); |
||||
int r = pthread_mutex_destroy(&mutex->pmutex); |
||||
assert_zero(r); |
||||
} |
||||
|
||||
#define toku_pthread_rwlock_rdlock(RW) \ |
||||
toku_pthread_rwlock_rdlock_with_source_location(RW, __FILE__, __LINE__) |
||||
|
||||
#define toku_pthread_rwlock_wrlock(RW) \ |
||||
toku_pthread_rwlock_wrlock_with_source_location(RW, __FILE__, __LINE__) |
||||
|
||||
#if 0 |
||||
inline void toku_pthread_rwlock_init( |
||||
const toku_instr_key &key, |
||||
toku_pthread_rwlock_t *__restrict rwlock, |
||||
const toku_pthread_rwlockattr_t *__restrict attr) { |
||||
toku_instr_rwlock_init(key, *rwlock); |
||||
int r = pthread_rwlock_init(&rwlock->rwlock, attr); |
||||
assert_zero(r); |
||||
} |
||||
|
||||
inline void toku_pthread_rwlock_destroy(toku_pthread_rwlock_t *rwlock) { |
||||
toku_instr_rwlock_destroy(rwlock->psi_rwlock); |
||||
int r = pthread_rwlock_destroy(&rwlock->rwlock); |
||||
assert_zero(r); |
||||
} |
||||
|
||||
inline void toku_pthread_rwlock_rdlock_with_source_location( |
||||
toku_pthread_rwlock_t *rwlock, |
||||
const char *src_file, |
||||
uint src_line) { |
||||
|
||||
/* Instrumentation start */ |
||||
toku_rwlock_instrumentation rwlock_instr; |
||||
toku_instr_rwlock_rdlock_wait_start( |
||||
rwlock_instr, *rwlock, src_file, src_line); |
||||
/* Instrumented code */ |
||||
const int r = pthread_rwlock_rdlock(&rwlock->rwlock); |
||||
|
||||
/* Instrumentation end */ |
||||
toku_instr_rwlock_rdlock_wait_end(rwlock_instr, r); |
||||
|
||||
assert_zero(r); |
||||
} |
||||
|
||||
inline void toku_pthread_rwlock_wrlock_with_source_location( |
||||
toku_pthread_rwlock_t *rwlock, |
||||
const char *src_file, |
||||
uint src_line) { |
||||
|
||||
/* Instrumentation start */ |
||||
toku_rwlock_instrumentation rwlock_instr; |
||||
toku_instr_rwlock_wrlock_wait_start( |
||||
rwlock_instr, *rwlock, src_file, src_line); |
||||
/* Instrumented code */ |
||||
const int r = pthread_rwlock_wrlock(&rwlock->rwlock); |
||||
|
||||
/* Instrumentation end */ |
||||
toku_instr_rwlock_wrlock_wait_end(rwlock_instr, r); |
||||
|
||||
assert_zero(r); |
||||
} |
||||
|
||||
inline void toku_pthread_rwlock_rdunlock(toku_pthread_rwlock_t *rwlock) { |
||||
toku_instr_rwlock_unlock(*rwlock); |
||||
const int r = pthread_rwlock_unlock(&rwlock->rwlock); |
||||
assert_zero(r); |
||||
} |
||||
|
||||
inline void toku_pthread_rwlock_wrunlock(toku_pthread_rwlock_t *rwlock) { |
||||
toku_instr_rwlock_unlock(*rwlock); |
||||
const int r = pthread_rwlock_unlock(&rwlock->rwlock); |
||||
assert_zero(r); |
||||
} |
||||
#endif |
||||
|
||||
static inline int toku_pthread_join(toku_pthread_t thread, void **value_ptr) { |
||||
return pthread_join(thread, value_ptr); |
||||
} |
||||
|
||||
static inline int toku_pthread_detach(toku_pthread_t thread) { |
||||
return pthread_detach(thread); |
||||
} |
||||
|
||||
static inline int toku_pthread_key_create(toku_pthread_key_t *key, |
||||
void (*destroyf)(void *)) { |
||||
return pthread_key_create(key, destroyf); |
||||
} |
||||
|
||||
static inline int toku_pthread_key_delete(toku_pthread_key_t key) { |
||||
return pthread_key_delete(key); |
||||
} |
||||
|
||||
static inline void *toku_pthread_getspecific(toku_pthread_key_t key) { |
||||
return pthread_getspecific(key); |
||||
} |
||||
|
||||
static inline int toku_pthread_setspecific(toku_pthread_key_t key, void *data) { |
||||
return pthread_setspecific(key, data); |
||||
} |
||||
|
||||
int toku_pthread_yield(void) __attribute__((__visibility__("default"))); |
||||
|
||||
static inline toku_pthread_t toku_pthread_self(void) { return pthread_self(); } |
||||
|
||||
static inline void *toku_pthread_done(void *exit_value) { |
||||
toku_instr_delete_current_thread(); |
||||
pthread_exit(exit_value); |
||||
return nullptr; // Avoid compiler warning
|
||||
} |
||||
@ -0,0 +1,165 @@ |
||||
/* -*- mode: C++; c-basic-offset: 4; indent-tabs-mode: nil -*- */ |
||||
// vim: ft=cpp:expandtab:ts=8:sw=4:softtabstop=4:
|
||||
#ident "$Id$" |
||||
/*======
|
||||
This file is part of PerconaFT. |
||||
|
||||
|
||||
Copyright (c) 2006, 2015, Percona and/or its affiliates. All rights reserved. |
||||
|
||||
PerconaFT is free software: you can redistribute it and/or modify |
||||
it under the terms of the GNU General Public License, version 2, |
||||
as published by the Free Software Foundation. |
||||
|
||||
PerconaFT is distributed in the hope that it will be useful, |
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
GNU General Public License for more details. |
||||
|
||||
You should have received a copy of the GNU General Public License |
||||
along with PerconaFT. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
---------------------------------------- |
||||
|
||||
PerconaFT is free software: you can redistribute it and/or modify |
||||
it under the terms of the GNU Affero General Public License, version 3, |
||||
as published by the Free Software Foundation. |
||||
|
||||
PerconaFT is distributed in the hope that it will be useful, |
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
GNU Affero General Public License for more details. |
||||
|
||||
You should have received a copy of the GNU Affero General Public License |
||||
along with PerconaFT. If not, see <http://www.gnu.org/licenses/>.
|
||||
======= */ |
||||
|
||||
#ident \ |
||||
"Copyright (c) 2006, 2015, Percona and/or its affiliates. All rights reserved." |
||||
|
||||
#pragma once |
||||
|
||||
// PORT2: #include <portability/toku_config.h>
|
||||
|
||||
#ifdef HAVE_valgrind |
||||
#undef USE_VALGRIND |
||||
#define USE_VALGRIND 1 |
||||
#endif |
||||
|
||||
#if defined(__linux__) && USE_VALGRIND |
||||
|
||||
#include <valgrind/drd.h> |
||||
#include <valgrind/helgrind.h> |
||||
|
||||
#define TOKU_ANNOTATE_NEW_MEMORY(p, size) ANNOTATE_NEW_MEMORY(p, size) |
||||
#define TOKU_VALGRIND_HG_ENABLE_CHECKING(p, size) \ |
||||
VALGRIND_HG_ENABLE_CHECKING(p, size) |
||||
#define TOKU_VALGRIND_HG_DISABLE_CHECKING(p, size) \ |
||||
VALGRIND_HG_DISABLE_CHECKING(p, size) |
||||
#define TOKU_DRD_IGNORE_VAR(v) DRD_IGNORE_VAR(v) |
||||
#define TOKU_DRD_STOP_IGNORING_VAR(v) DRD_STOP_IGNORING_VAR(v) |
||||
#define TOKU_ANNOTATE_IGNORE_READS_BEGIN() ANNOTATE_IGNORE_READS_BEGIN() |
||||
#define TOKU_ANNOTATE_IGNORE_READS_END() ANNOTATE_IGNORE_READS_END() |
||||
#define TOKU_ANNOTATE_IGNORE_WRITES_BEGIN() ANNOTATE_IGNORE_WRITES_BEGIN() |
||||
#define TOKU_ANNOTATE_IGNORE_WRITES_END() ANNOTATE_IGNORE_WRITES_END() |
||||
|
||||
/*
|
||||
* How to make helgrind happy about tree rotations and new mutex orderings: |
||||
* |
||||
* // Tell helgrind that we unlocked it so that the next call doesn't get a
|
||||
* "destroyed a locked mutex" error. |
||||
* // Tell helgrind that we destroyed the mutex.
|
||||
* VALGRIND_HG_MUTEX_UNLOCK_PRE(&locka); |
||||
* VALGRIND_HG_MUTEX_DESTROY_PRE(&locka); |
||||
* |
||||
* // And recreate it. It would be better to simply be able to say that the
|
||||
* order on these two can now be reversed, because this code forgets all the |
||||
* ordering information for this mutex. |
||||
* // Then tell helgrind that we have locked it again.
|
||||
* VALGRIND_HG_MUTEX_INIT_POST(&locka, 0); |
||||
* VALGRIND_HG_MUTEX_LOCK_POST(&locka); |
||||
* |
||||
* When the ordering of two locks changes, we don't need tell Helgrind about do |
||||
* both locks. Just one is good enough. |
||||
*/ |
||||
|
||||
#define TOKU_VALGRIND_RESET_MUTEX_ORDERING_INFO(mutex) \ |
||||
VALGRIND_HG_MUTEX_UNLOCK_PRE(mutex); \
|
||||
VALGRIND_HG_MUTEX_DESTROY_PRE(mutex); \
|
||||
VALGRIND_HG_MUTEX_INIT_POST(mutex, 0); \
|
||||
VALGRIND_HG_MUTEX_LOCK_POST(mutex); |
||||
|
||||
#else // !defined(__linux__) || !USE_VALGRIND
|
||||
|
||||
#define NVALGRIND 1 |
||||
#define TOKU_ANNOTATE_NEW_MEMORY(p, size) ((void)0) |
||||
#define TOKU_VALGRIND_HG_ENABLE_CHECKING(p, size) ((void)0) |
||||
#define TOKU_VALGRIND_HG_DISABLE_CHECKING(p, size) ((void)0) |
||||
#define TOKU_DRD_IGNORE_VAR(v) |
||||
#define TOKU_DRD_STOP_IGNORING_VAR(v) |
||||
#define TOKU_ANNOTATE_IGNORE_READS_BEGIN() ((void)0) |
||||
#define TOKU_ANNOTATE_IGNORE_READS_END() ((void)0) |
||||
#define TOKU_ANNOTATE_IGNORE_WRITES_BEGIN() ((void)0) |
||||
#define TOKU_ANNOTATE_IGNORE_WRITES_END() ((void)0) |
||||
#define TOKU_VALGRIND_RESET_MUTEX_ORDERING_INFO(mutex) |
||||
#undef RUNNING_ON_VALGRIND |
||||
#define RUNNING_ON_VALGRIND (0U) |
||||
#endif |
||||
|
||||
// Valgrind 3.10.1 (and previous versions).
|
||||
// Problems with VALGRIND_HG_DISABLE_CHECKING and VALGRIND_HG_ENABLE_CHECKING.
|
||||
// Helgrind's implementation of disable and enable checking causes false races
|
||||
// to be reported. In addition, the race report does not include ANY
|
||||
// information about the code that uses the helgrind disable and enable
|
||||
// functions. Therefore, it is very difficult to figure out the cause of the
|
||||
// race. DRD does implement the disable and enable functions.
|
||||
|
||||
// Problems with ANNOTATE_IGNORE_READS.
|
||||
// Helgrind does not implement ignore reads.
|
||||
// Annotate ignore reads is the way to inform DRD to ignore racy reads.
|
||||
|
||||
// FT code uses unsafe reads in several places. These unsafe reads have been
|
||||
// noted as valid since they use the toku_unsafe_fetch function. Unfortunately,
|
||||
// this causes helgrind to report erroneous data races which makes use of
|
||||
// helgrind problematic.
|
||||
|
||||
// Unsafely fetch and return a `T' from src, telling drd to ignore
|
||||
// racey access to src for the next sizeof(*src) bytes
|
||||
template <typename T> |
||||
T toku_unsafe_fetch(T *src) { |
||||
if (0) |
||||
TOKU_VALGRIND_HG_DISABLE_CHECKING(src, |
||||
sizeof *src); // disabled, see comment
|
||||
TOKU_ANNOTATE_IGNORE_READS_BEGIN(); |
||||
T r = *src; |
||||
TOKU_ANNOTATE_IGNORE_READS_END(); |
||||
if (0) |
||||
TOKU_VALGRIND_HG_ENABLE_CHECKING(src, |
||||
sizeof *src); // disabled, see comment
|
||||
return r; |
||||
} |
||||
|
||||
template <typename T> |
||||
T toku_unsafe_fetch(T &src) { |
||||
return toku_unsafe_fetch(&src); |
||||
} |
||||
|
||||
// Unsafely set a `T' value into *dest from src, telling drd to ignore
|
||||
// racey access to dest for the next sizeof(*dest) bytes
|
||||
template <typename T> |
||||
void toku_unsafe_set(T *dest, const T src) { |
||||
if (0) |
||||
TOKU_VALGRIND_HG_DISABLE_CHECKING(dest, |
||||
sizeof *dest); // disabled, see comment
|
||||
TOKU_ANNOTATE_IGNORE_WRITES_BEGIN(); |
||||
*dest = src; |
||||
TOKU_ANNOTATE_IGNORE_WRITES_END(); |
||||
if (0) |
||||
TOKU_VALGRIND_HG_ENABLE_CHECKING(dest, |
||||
sizeof *dest); // disabled, see comment
|
||||
} |
||||
|
||||
template <typename T> |
||||
void toku_unsafe_set(T &dest, const T src) { |
||||
toku_unsafe_set(&dest, src); |
||||
} |
||||
@ -0,0 +1,158 @@ |
||||
/* -*- mode: C++; c-basic-offset: 4; indent-tabs-mode: nil -*- */ |
||||
// vim: ft=cpp:expandtab:ts=8:sw=4:softtabstop=4:
|
||||
#ident "$Id$" |
||||
/*======
|
||||
This file is part of PerconaFT. |
||||
|
||||
|
||||
Copyright (c) 2006, 2015, Percona and/or its affiliates. All rights reserved. |
||||
|
||||
PerconaFT is free software: you can redistribute it and/or modify |
||||
it under the terms of the GNU General Public License, version 2, |
||||
as published by the Free Software Foundation. |
||||
|
||||
PerconaFT is distributed in the hope that it will be useful, |
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
GNU General Public License for more details. |
||||
|
||||
You should have received a copy of the GNU General Public License |
||||
along with PerconaFT. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
---------------------------------------- |
||||
|
||||
PerconaFT is free software: you can redistribute it and/or modify |
||||
it under the terms of the GNU Affero General Public License, version 3, |
||||
as published by the Free Software Foundation. |
||||
|
||||
PerconaFT is distributed in the hope that it will be useful, |
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
GNU Affero General Public License for more details. |
||||
|
||||
You should have received a copy of the GNU Affero General Public License |
||||
along with PerconaFT. If not, see <http://www.gnu.org/licenses/>.
|
||||
======= */ |
||||
|
||||
#ident \ |
||||
"Copyright (c) 2006, 2015, Percona and/or its affiliates. All rights reserved." |
||||
|
||||
#pragma once |
||||
|
||||
// PORT2: #include "toku_config.h"
|
||||
|
||||
#include <stdint.h> |
||||
#include <sys/time.h> |
||||
#include <time.h> |
||||
#if defined(__powerpc__) |
||||
#include <sys/platform/ppc.h> |
||||
#endif |
||||
|
||||
#if 0 |
||||
static inline float toku_tdiff (struct timeval *a, struct timeval *b) { |
||||
return (float)((a->tv_sec - b->tv_sec) + 1e-6 * (a->tv_usec - b->tv_usec)); |
||||
} |
||||
// PORT2: temporary:
|
||||
#define HAVE_CLOCK_REALTIME |
||||
#if !defined(HAVE_CLOCK_REALTIME) |
||||
// OS X does not have clock_gettime, we fake clockid_t for the interface, and we'll implement it with clock_get_time.
|
||||
typedef int clockid_t; |
||||
// just something bogus, it doesn't matter, we just want to make sure we're
|
||||
// only supporting this mode because we're not sure we can support other modes
|
||||
// without a real clock_gettime()
|
||||
#define CLOCK_REALTIME 0x01867234 |
||||
#endif |
||||
int toku_clock_gettime(clockid_t clk_id, struct timespec *ts) __attribute__((__visibility__("default"))); |
||||
#endif |
||||
|
||||
// *************** Performance timers ************************
|
||||
// What do you really want from a performance timer:
|
||||
// (1) Can determine actual time of day from the performance time.
|
||||
// (2) Time goes forward, never backward.
|
||||
// (3) Same time on different processors (or even different machines).
|
||||
// (4) Time goes forward at a constant rate (doesn't get faster and slower)
|
||||
// (5) Portable.
|
||||
// (6) Getting the time is cheap.
|
||||
// Unfortuately it seems tough to get Properties 1-5. So we go for Property 6,,
|
||||
// but we abstract it. We offer a type tokutime_t which can hold the time. This
|
||||
// type can be subtracted to get a time difference. We can get the present time
|
||||
// cheaply. We can convert this type to seconds (but that can be expensive). The
|
||||
// implementation is to use RDTSC (hence we lose property 3: not portable).
|
||||
// Recent machines have constant_tsc in which case we get property (4).
|
||||
// Recent OSs on recent machines (that have RDTSCP) fix the per-processor clock
|
||||
// skew, so we get property (3). We get property 2 with RDTSC (as long as
|
||||
// there's not any skew). We don't even try to get propety 1, since we don't
|
||||
// need it. The decision here is that these times are really accurate only on
|
||||
// modern machines with modern OSs.
|
||||
typedef uint64_t tokutime_t; // Time type used in by tokutek timers.
|
||||
|
||||
#if 0 |
||||
// The value of tokutime_t is not specified here.
|
||||
// It might be microseconds since 1/1/1970 (if gettimeofday() is
|
||||
// used), or clock cycles since boot (if rdtsc is used). Or something
|
||||
// else.
|
||||
// Two tokutime_t values can be subtracted to get a time difference.
|
||||
// Use tokutime_to_seconds to that convert difference to seconds.
|
||||
// We want get_tokutime() to be fast, but don't care so much about tokutime_to_seconds();
|
||||
//
|
||||
// For accurate time calculations do the subtraction in the right order:
|
||||
// Right: tokutime_to_seconds(t1-t2);
|
||||
// Wrong tokutime_to_seconds(t1)-toku_time_to_seconds(t2);
|
||||
// Doing it the wrong way is likely to result in loss of precision.
|
||||
// A double can hold numbers up to about 53 bits. RDTSC which uses about 33 bits every second, so that leaves
|
||||
// 2^20 seconds from booting (about 2 weeks) before the RDTSC value cannot be represented accurately as a double.
|
||||
//
|
||||
double tokutime_to_seconds(tokutime_t) __attribute__((__visibility__("default"))); // Convert tokutime to seconds.
|
||||
|
||||
#endif |
||||
|
||||
// Get the value of tokutime for right now. We want this to be fast, so we
|
||||
// expose the implementation as RDTSC.
|
||||
static inline tokutime_t toku_time_now(void) { |
||||
#if defined(__x86_64__) || defined(__i386__) |
||||
uint32_t lo, hi; |
||||
__asm__ __volatile__("rdtsc" : "=a"(lo), "=d"(hi)); |
||||
return (uint64_t)hi << 32 | lo; |
||||
#elif defined(__aarch64__) |
||||
uint64_t result; |
||||
__asm __volatile__("mrs %[rt], cntvct_el0" : [ rt ] "=r"(result)); |
||||
return result; |
||||
#elif defined(__powerpc__) |
||||
return __ppc_get_timebase(); |
||||
#else |
||||
#error No timer implementation for this platform |
||||
#endif |
||||
} |
||||
|
||||
static inline uint64_t toku_current_time_microsec(void) { |
||||
struct timeval t; |
||||
gettimeofday(&t, NULL); |
||||
return t.tv_sec * (1UL * 1000 * 1000) + t.tv_usec; |
||||
} |
||||
|
||||
#if 0 |
||||
// sleep microseconds
|
||||
static inline void toku_sleep_microsec(uint64_t ms) { |
||||
struct timeval t; |
||||
|
||||
t.tv_sec = ms / 1000000; |
||||
t.tv_usec = ms % 1000000; |
||||
|
||||
select(0, NULL, NULL, NULL, &t); |
||||
} |
||||
#endif |
||||
|
||||
/*
|
||||
PORT: Usage of this file: |
||||
|
||||
uint64_t toku_current_time_microsec() // uses gettimeoday
|
||||
is used to track how much time various operations took (for example, lock |
||||
escalation). (TODO: it is not clear why these operations are tracked with |
||||
microsecond precision while others use nanoseconds) |
||||
|
||||
tokutime_t toku_time_now() // uses rdtsc
|
||||
seems to be used for a very similar purpose. This has greater precision |
||||
|
||||
RocksDB environment provides Env::Default()->NowMicros() and NowNanos() which |
||||
should be adequate substitutes. |
||||
*/ |
||||
@ -0,0 +1,27 @@ |
||||
//
|
||||
// A substitute for ft/txn/txn.h
|
||||
//
|
||||
#pragma once |
||||
|
||||
#include <set> |
||||
|
||||
#include "../util/omt.h" |
||||
|
||||
typedef uint64_t TXNID; |
||||
#define TXNID_NONE ((TXNID)0) |
||||
|
||||
// A set of transactions
|
||||
// (TODO: consider using class toku::txnid_set. The reason for using STL
|
||||
// container was that its API is easier)
|
||||
class TxnidVector : public std::set<TXNID> { |
||||
public: |
||||
bool contains(TXNID txnid) { return find(txnid) != end(); } |
||||
}; |
||||
|
||||
// A value for lock structures with a meaning "the lock is owned by multiple
|
||||
// transactions (and one has to check the TxnidVector to get their ids)
|
||||
#define TXNID_SHARED (TXNID(-1)) |
||||
|
||||
// Auxiliary value meaning "any transaction id will do". No real transaction
|
||||
// may have this is as id.
|
||||
#define TXNID_ANY (TXNID(-2)) |
||||
@ -0,0 +1,132 @@ |
||||
#ifndef ROCKSDB_LITE |
||||
#ifndef OS_WIN |
||||
/*
|
||||
This is a dump ground to make Lock Tree work without the rest of TokuDB. |
||||
*/ |
||||
#include <string.h> |
||||
|
||||
#include "db.h" |
||||
#include "ft/ft-status.h" |
||||
#include "portability/memory.h" |
||||
#include "util/dbt.h" |
||||
|
||||
// portability/os_malloc.cc
|
||||
|
||||
void toku_free(void *p) { free(p); } |
||||
|
||||
void *toku_xmalloc(size_t size) { return malloc(size); } |
||||
|
||||
void *toku_xrealloc(void *v, size_t size) { return realloc(v, size); } |
||||
|
||||
void *toku_xmemdup(const void *v, size_t len) { |
||||
void *p = toku_xmalloc(len); |
||||
memcpy(p, v, len); |
||||
return p; |
||||
} |
||||
|
||||
// TODO: what are the X-functions? Xcalloc, Xrealloc?
|
||||
void *toku_xcalloc(size_t nmemb, size_t size) { return calloc(nmemb, size); } |
||||
|
||||
// ft-ft-opts.cc:
|
||||
|
||||
// locktree
|
||||
toku_instr_key lock_request_m_wait_cond_key; |
||||
toku_instr_key manager_m_escalator_done_key; |
||||
toku_instr_key locktree_request_info_mutex_key; |
||||
toku_instr_key locktree_request_info_retry_mutex_key; |
||||
toku_instr_key locktree_request_info_retry_cv_key; |
||||
|
||||
toku_instr_key treenode_mutex_key; |
||||
toku_instr_key manager_mutex_key; |
||||
toku_instr_key manager_escalation_mutex_key; |
||||
toku_instr_key manager_escalator_mutex_key; |
||||
|
||||
// portability/memory.cc
|
||||
size_t toku_memory_footprint(void *, size_t touched) { return touched; } |
||||
|
||||
// ft/ft-status.c
|
||||
// PORT2: note: the @c parameter to TOKUFT_STATUS_INIT must not start with
|
||||
// "TOKU"
|
||||
LTM_STATUS_S ltm_status; |
||||
void LTM_STATUS_S::init() { |
||||
if (m_initialized) return; |
||||
#define LTM_STATUS_INIT(k, c, t, l) \ |
||||
TOKUFT_STATUS_INIT((*this), k, c, t, "locktree: " l, \
|
||||
TOKU_ENGINE_STATUS | TOKU_GLOBAL_STATUS) |
||||
LTM_STATUS_INIT(LTM_SIZE_CURRENT, LOCKTREE_MEMORY_SIZE, STATUS_UINT64, |
||||
"memory size"); |
||||
LTM_STATUS_INIT(LTM_SIZE_LIMIT, LOCKTREE_MEMORY_SIZE_LIMIT, STATUS_UINT64, |
||||
"memory size limit"); |
||||
LTM_STATUS_INIT(LTM_ESCALATION_COUNT, LOCKTREE_ESCALATION_NUM, STATUS_UINT64, |
||||
"number of times lock escalation ran"); |
||||
LTM_STATUS_INIT(LTM_ESCALATION_TIME, LOCKTREE_ESCALATION_SECONDS, |
||||
STATUS_TOKUTIME, "time spent running escalation (seconds)"); |
||||
LTM_STATUS_INIT(LTM_ESCALATION_LATEST_RESULT, |
||||
LOCKTREE_LATEST_POST_ESCALATION_MEMORY_SIZE, STATUS_UINT64, |
||||
"latest post-escalation memory size"); |
||||
LTM_STATUS_INIT(LTM_NUM_LOCKTREES, LOCKTREE_OPEN_CURRENT, STATUS_UINT64, |
||||
"number of locktrees open now"); |
||||
LTM_STATUS_INIT(LTM_LOCK_REQUESTS_PENDING, LOCKTREE_PENDING_LOCK_REQUESTS, |
||||
STATUS_UINT64, "number of pending lock requests"); |
||||
LTM_STATUS_INIT(LTM_STO_NUM_ELIGIBLE, LOCKTREE_STO_ELIGIBLE_NUM, |
||||
STATUS_UINT64, "number of locktrees eligible for the STO"); |
||||
LTM_STATUS_INIT(LTM_STO_END_EARLY_COUNT, LOCKTREE_STO_ENDED_NUM, |
||||
STATUS_UINT64, |
||||
"number of times a locktree ended the STO early"); |
||||
LTM_STATUS_INIT(LTM_STO_END_EARLY_TIME, LOCKTREE_STO_ENDED_SECONDS, |
||||
STATUS_TOKUTIME, "time spent ending the STO early (seconds)"); |
||||
LTM_STATUS_INIT(LTM_WAIT_COUNT, LOCKTREE_WAIT_COUNT, STATUS_UINT64, |
||||
"number of wait locks"); |
||||
LTM_STATUS_INIT(LTM_WAIT_TIME, LOCKTREE_WAIT_TIME, STATUS_UINT64, |
||||
"time waiting for locks"); |
||||
LTM_STATUS_INIT(LTM_LONG_WAIT_COUNT, LOCKTREE_LONG_WAIT_COUNT, STATUS_UINT64, |
||||
"number of long wait locks"); |
||||
LTM_STATUS_INIT(LTM_LONG_WAIT_TIME, LOCKTREE_LONG_WAIT_TIME, STATUS_UINT64, |
||||
"long time waiting for locks"); |
||||
LTM_STATUS_INIT(LTM_TIMEOUT_COUNT, LOCKTREE_TIMEOUT_COUNT, STATUS_UINT64, |
||||
"number of lock timeouts"); |
||||
LTM_STATUS_INIT(LTM_WAIT_ESCALATION_COUNT, LOCKTREE_WAIT_ESCALATION_COUNT, |
||||
STATUS_UINT64, "number of waits on lock escalation"); |
||||
LTM_STATUS_INIT(LTM_WAIT_ESCALATION_TIME, LOCKTREE_WAIT_ESCALATION_TIME, |
||||
STATUS_UINT64, "time waiting on lock escalation"); |
||||
LTM_STATUS_INIT(LTM_LONG_WAIT_ESCALATION_COUNT, |
||||
LOCKTREE_LONG_WAIT_ESCALATION_COUNT, STATUS_UINT64, |
||||
"number of long waits on lock escalation"); |
||||
LTM_STATUS_INIT(LTM_LONG_WAIT_ESCALATION_TIME, |
||||
LOCKTREE_LONG_WAIT_ESCALATION_TIME, STATUS_UINT64, |
||||
"long time waiting on lock escalation"); |
||||
|
||||
m_initialized = true; |
||||
#undef LTM_STATUS_INIT |
||||
} |
||||
void LTM_STATUS_S::destroy() { |
||||
if (!m_initialized) return; |
||||
for (int i = 0; i < LTM_STATUS_NUM_ROWS; ++i) { |
||||
if (status[i].type == STATUS_PARCOUNT) { |
||||
// PORT: TODO?? destroy_partitioned_counter(status[i].value.parcount);
|
||||
} |
||||
} |
||||
} |
||||
|
||||
int toku_keycompare(const void *key1, size_t key1len, const void *key2, |
||||
size_t key2len) { |
||||
size_t comparelen = key1len < key2len ? key1len : key2len; |
||||
int c = memcmp(key1, key2, comparelen); |
||||
if (__builtin_expect(c != 0, 1)) { |
||||
return c; |
||||
} else { |
||||
if (key1len < key2len) { |
||||
return -1; |
||||
} else if (key1len > key2len) { |
||||
return 1; |
||||
} else { |
||||
return 0; |
||||
} |
||||
} |
||||
} |
||||
|
||||
int toku_builtin_compare_fun(const DBT *a, const DBT *b) { |
||||
return toku_keycompare(a->data, a->size, b->data, b->size); |
||||
} |
||||
#endif // OS_WIN
|
||||
#endif // ROCKSDB_LITE
|
||||
@ -0,0 +1,153 @@ |
||||
/* -*- mode: C++; c-basic-offset: 4; indent-tabs-mode: nil -*- */ |
||||
// vim: ft=cpp:expandtab:ts=8:sw=4:softtabstop=4:
|
||||
#ifndef ROCKSDB_LITE |
||||
#ifndef OS_WIN |
||||
#ident "$Id$" |
||||
/*======
|
||||
This file is part of PerconaFT. |
||||
|
||||
|
||||
Copyright (c) 2006, 2015, Percona and/or its affiliates. All rights reserved. |
||||
|
||||
PerconaFT is free software: you can redistribute it and/or modify |
||||
it under the terms of the GNU General Public License, version 2, |
||||
as published by the Free Software Foundation. |
||||
|
||||
PerconaFT is distributed in the hope that it will be useful, |
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
GNU General Public License for more details. |
||||
|
||||
You should have received a copy of the GNU General Public License |
||||
along with PerconaFT. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
---------------------------------------- |
||||
|
||||
PerconaFT is free software: you can redistribute it and/or modify |
||||
it under the terms of the GNU Affero General Public License, version 3, |
||||
as published by the Free Software Foundation. |
||||
|
||||
PerconaFT is distributed in the hope that it will be useful, |
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
GNU Affero General Public License for more details. |
||||
|
||||
You should have received a copy of the GNU Affero General Public License |
||||
along with PerconaFT. If not, see <http://www.gnu.org/licenses/>.
|
||||
======= */ |
||||
|
||||
#ident \ |
||||
"Copyright (c) 2006, 2015, Percona and/or its affiliates. All rights reserved." |
||||
|
||||
#include "dbt.h" |
||||
|
||||
#include <string.h> |
||||
|
||||
#include "../db.h" |
||||
#include "../portability/memory.h" |
||||
|
||||
DBT *toku_init_dbt(DBT *dbt) { |
||||
memset(dbt, 0, sizeof(*dbt)); |
||||
return dbt; |
||||
} |
||||
|
||||
DBT toku_empty_dbt(void) { |
||||
static const DBT empty_dbt = {.data = 0, .size = 0, .ulen = 0, .flags = 0}; |
||||
return empty_dbt; |
||||
} |
||||
|
||||
DBT *toku_init_dbt_flags(DBT *dbt, uint32_t flags) { |
||||
toku_init_dbt(dbt); |
||||
dbt->flags = flags; |
||||
return dbt; |
||||
} |
||||
|
||||
void toku_destroy_dbt(DBT *dbt) { |
||||
switch (dbt->flags) { |
||||
case DB_DBT_MALLOC: |
||||
case DB_DBT_REALLOC: |
||||
toku_free(dbt->data); |
||||
toku_init_dbt(dbt); |
||||
break; |
||||
} |
||||
} |
||||
|
||||
DBT *toku_fill_dbt(DBT *dbt, const void *k, size_t len) { |
||||
toku_init_dbt(dbt); |
||||
dbt->size = len; |
||||
dbt->data = (char *)k; |
||||
return dbt; |
||||
} |
||||
|
||||
DBT *toku_memdup_dbt(DBT *dbt, const void *k, size_t len) { |
||||
toku_init_dbt_flags(dbt, DB_DBT_MALLOC); |
||||
dbt->size = len; |
||||
dbt->data = toku_xmemdup(k, len); |
||||
return dbt; |
||||
} |
||||
|
||||
DBT *toku_copyref_dbt(DBT *dst, const DBT src) { |
||||
dst->flags = 0; |
||||
dst->ulen = 0; |
||||
dst->size = src.size; |
||||
dst->data = src.data; |
||||
return dst; |
||||
} |
||||
|
||||
DBT *toku_clone_dbt(DBT *dst, const DBT &src) { |
||||
return toku_memdup_dbt(dst, src.data, src.size); |
||||
} |
||||
|
||||
void toku_sdbt_cleanup(struct simple_dbt *sdbt) { |
||||
if (sdbt->data) toku_free(sdbt->data); |
||||
memset(sdbt, 0, sizeof(*sdbt)); |
||||
} |
||||
|
||||
const DBT *toku_dbt_positive_infinity(void) { |
||||
static DBT positive_infinity_dbt = { |
||||
.data = 0, .size = 0, .ulen = 0, .flags = 0}; // port
|
||||
return &positive_infinity_dbt; |
||||
} |
||||
|
||||
const DBT *toku_dbt_negative_infinity(void) { |
||||
static DBT negative_infinity_dbt = { |
||||
.data = 0, .size = 0, .ulen = 0, .flags = 0}; // port
|
||||
return &negative_infinity_dbt; |
||||
} |
||||
|
||||
bool toku_dbt_is_infinite(const DBT *dbt) { |
||||
return dbt == toku_dbt_positive_infinity() || |
||||
dbt == toku_dbt_negative_infinity(); |
||||
} |
||||
|
||||
bool toku_dbt_is_empty(const DBT *dbt) { |
||||
// can't have a null data field with a non-zero size
|
||||
paranoid_invariant(dbt->data != nullptr || dbt->size == 0); |
||||
return dbt->data == nullptr; |
||||
} |
||||
|
||||
int toku_dbt_infinite_compare(const DBT *a, const DBT *b) { |
||||
if (a == b) { |
||||
return 0; |
||||
} else if (a == toku_dbt_positive_infinity()) { |
||||
return 1; |
||||
} else if (b == toku_dbt_positive_infinity()) { |
||||
return -1; |
||||
} else if (a == toku_dbt_negative_infinity()) { |
||||
return -1; |
||||
} else { |
||||
invariant(b == toku_dbt_negative_infinity()); |
||||
return 1; |
||||
} |
||||
} |
||||
|
||||
bool toku_dbt_equals(const DBT *a, const DBT *b) { |
||||
if (!toku_dbt_is_infinite(a) && !toku_dbt_is_infinite(b)) { |
||||
return a->data == b->data && a->size == b->size; |
||||
} else { |
||||
// a or b is infinite, so they're equal if they are the same infinite
|
||||
return a == b ? true : false; |
||||
} |
||||
} |
||||
#endif // OS_WIN
|
||||
#endif // ROCKSDB_LITE
|
||||
@ -0,0 +1,84 @@ |
||||
/* -*- mode: C++; c-basic-offset: 4; indent-tabs-mode: nil -*- */ |
||||
// vim: ft=cpp:expandtab:ts=8:sw=4:softtabstop=4:
|
||||
#ident "$Id$" |
||||
/*======
|
||||
This file is part of PerconaFT. |
||||
|
||||
|
||||
Copyright (c) 2006, 2015, Percona and/or its affiliates. All rights reserved. |
||||
|
||||
PerconaFT is free software: you can redistribute it and/or modify |
||||
it under the terms of the GNU General Public License, version 2, |
||||
as published by the Free Software Foundation. |
||||
|
||||
PerconaFT is distributed in the hope that it will be useful, |
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
GNU General Public License for more details. |
||||
|
||||
You should have received a copy of the GNU General Public License |
||||
along with PerconaFT. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
---------------------------------------- |
||||
|
||||
PerconaFT is free software: you can redistribute it and/or modify |
||||
it under the terms of the GNU Affero General Public License, version 3, |
||||
as published by the Free Software Foundation. |
||||
|
||||
PerconaFT is distributed in the hope that it will be useful, |
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
GNU Affero General Public License for more details. |
||||
|
||||
You should have received a copy of the GNU Affero General Public License |
||||
along with PerconaFT. If not, see <http://www.gnu.org/licenses/>.
|
||||
======= */ |
||||
|
||||
#ident \ |
||||
"Copyright (c) 2006, 2015, Percona and/or its affiliates. All rights reserved." |
||||
|
||||
#pragma once |
||||
|
||||
#include "../db.h" |
||||
|
||||
// TODO: John
|
||||
// Document this API a little better so that DBT
|
||||
// memory management can be morm widely understood.
|
||||
|
||||
DBT *toku_init_dbt(DBT *); |
||||
|
||||
// returns: an initialized but empty dbt (for which toku_dbt_is_empty() is true)
|
||||
DBT toku_empty_dbt(void); |
||||
|
||||
DBT *toku_init_dbt_flags(DBT *, uint32_t flags); |
||||
|
||||
void toku_destroy_dbt(DBT *); |
||||
|
||||
DBT *toku_fill_dbt(DBT *dbt, const void *k, size_t len); |
||||
|
||||
DBT *toku_memdup_dbt(DBT *dbt, const void *k, size_t len); |
||||
|
||||
DBT *toku_copyref_dbt(DBT *dst, const DBT src); |
||||
|
||||
DBT *toku_clone_dbt(DBT *dst, const DBT &src); |
||||
|
||||
void toku_sdbt_cleanup(struct simple_dbt *sdbt); |
||||
|
||||
// returns: special DBT pointer representing positive infinity
|
||||
const DBT *toku_dbt_positive_infinity(void); |
||||
|
||||
// returns: special DBT pointer representing negative infinity
|
||||
const DBT *toku_dbt_negative_infinity(void); |
||||
|
||||
// returns: true if the given dbt is either positive or negative infinity
|
||||
bool toku_dbt_is_infinite(const DBT *dbt); |
||||
|
||||
// returns: true if the given dbt has no data (ie: dbt->data == nullptr)
|
||||
bool toku_dbt_is_empty(const DBT *dbt); |
||||
|
||||
// effect: compares two potentially infinity-valued dbts
|
||||
// requires: at least one is infinite (assert otherwise)
|
||||
int toku_dbt_infinite_compare(const DBT *a, const DBT *b); |
||||
|
||||
// returns: true if the given dbts have the same data pointer and size
|
||||
bool toku_dbt_equals(const DBT *a, const DBT *b); |
||||
@ -0,0 +1,143 @@ |
||||
/* -*- mode: C++; c-basic-offset: 4; indent-tabs-mode: nil -*- */ |
||||
// vim: ft=cpp:expandtab:ts=8:sw=4:softtabstop=4:
|
||||
#ident "$Id$" |
||||
/*======
|
||||
This file is part of PerconaFT. |
||||
|
||||
|
||||
Copyright (c) 2006, 2015, Percona and/or its affiliates. All rights reserved. |
||||
|
||||
PerconaFT is free software: you can redistribute it and/or modify |
||||
it under the terms of the GNU General Public License, version 2, |
||||
as published by the Free Software Foundation. |
||||
|
||||
PerconaFT is distributed in the hope that it will be useful, |
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
GNU General Public License for more details. |
||||
|
||||
You should have received a copy of the GNU General Public License |
||||
along with PerconaFT. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
---------------------------------------- |
||||
|
||||
PerconaFT is free software: you can redistribute it and/or modify |
||||
it under the terms of the GNU Affero General Public License, version 3, |
||||
as published by the Free Software Foundation. |
||||
|
||||
PerconaFT is distributed in the hope that it will be useful, |
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
GNU Affero General Public License for more details. |
||||
|
||||
You should have received a copy of the GNU Affero General Public License |
||||
along with PerconaFT. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
---------------------------------------- |
||||
|
||||
Licensed under the Apache License, Version 2.0 (the "License"); |
||||
you may not use this file except in compliance with the License. |
||||
You may obtain a copy of the License at |
||||
|
||||
http://www.apache.org/licenses/LICENSE-2.0
|
||||
|
||||
Unless required by applicable law or agreed to in writing, software |
||||
distributed under the License is distributed on an "AS IS" BASIS, |
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
||||
See the License for the specific language governing permissions and |
||||
======= */ |
||||
|
||||
#ident \ |
||||
"Copyright (c) 2006, 2015, Percona and/or its affiliates. All rights reserved." |
||||
|
||||
#pragma once |
||||
|
||||
#include <memory.h> |
||||
|
||||
//******************************************************************************
|
||||
//
|
||||
// Overview: A growable array is a little bit like std::vector except that
|
||||
// it doesn't have constructors (hence can be used in static constructs, since
|
||||
// the google style guide says no constructors), and it's a little simpler.
|
||||
// Operations:
|
||||
// init and deinit (we don't have constructors and destructors).
|
||||
// fetch_unchecked to get values out.
|
||||
// store_unchecked to put values in.
|
||||
// push to add an element at the end
|
||||
// get_size to find out the size
|
||||
// get_memory_size to find out how much memory the data stucture is using.
|
||||
//
|
||||
//******************************************************************************
|
||||
|
||||
namespace toku { |
||||
|
||||
template <typename T> |
||||
class GrowableArray { |
||||
public: |
||||
void init(void) |
||||
// Effect: Initialize the array to contain no elements.
|
||||
{ |
||||
m_array = NULL; |
||||
m_size = 0; |
||||
m_size_limit = 0; |
||||
} |
||||
|
||||
void deinit(void) |
||||
// Effect: Deinitialize the array (freeing any memory it uses, for example).
|
||||
{ |
||||
toku_free(m_array); |
||||
m_array = NULL; |
||||
m_size = 0; |
||||
m_size_limit = 0; |
||||
} |
||||
|
||||
T fetch_unchecked(size_t i) const |
||||
// Effect: Fetch the ith element. If i is out of range, the system asserts.
|
||||
{ |
||||
return m_array[i]; |
||||
} |
||||
|
||||
void store_unchecked(size_t i, T v) |
||||
// Effect: Store v in the ith element. If i is out of range, the system
|
||||
// asserts.
|
||||
{ |
||||
paranoid_invariant(i < m_size); |
||||
m_array[i] = v; |
||||
} |
||||
|
||||
void push(T v) |
||||
// Effect: Add v to the end of the array (increasing the size). The amortized
|
||||
// cost of this operation is constant. Implementation hint: Double the size
|
||||
// of the array when it gets too big so that the amortized cost stays
|
||||
// constant.
|
||||
{ |
||||
if (m_size >= m_size_limit) { |
||||
if (m_array == NULL) { |
||||
m_size_limit = 1; |
||||
} else { |
||||
m_size_limit *= 2; |
||||
} |
||||
XREALLOC_N(m_size_limit, m_array); |
||||
} |
||||
m_array[m_size++] = v; |
||||
} |
||||
|
||||
size_t get_size(void) const |
||||
// Effect: Return the number of elements in the array.
|
||||
{ |
||||
return m_size; |
||||
} |
||||
size_t memory_size(void) const |
||||
// Effect: Return the size (in bytes) that the array occupies in memory. This
|
||||
// is really only an estimate.
|
||||
{ |
||||
return sizeof(*this) + sizeof(T) * m_size_limit; |
||||
} |
||||
|
||||
private: |
||||
T *m_array; |
||||
size_t m_size; |
||||
size_t m_size_limit; // How much space is allocated in array.
|
||||
}; |
||||
|
||||
} // namespace toku
|
||||
@ -0,0 +1,187 @@ |
||||
/* -*- mode: C++; c-basic-offset: 4; indent-tabs-mode: nil -*- */ |
||||
// vim: ft=cpp:expandtab:ts=8:sw=4:softtabstop=4:
|
||||
#ifndef ROCKSDB_LITE |
||||
#ifndef OS_WIN |
||||
#ident "$Id$" |
||||
/*======
|
||||
This file is part of PerconaFT. |
||||
|
||||
|
||||
Copyright (c) 2006, 2015, Percona and/or its affiliates. All rights reserved. |
||||
|
||||
PerconaFT is free software: you can redistribute it and/or modify |
||||
it under the terms of the GNU General Public License, version 2, |
||||
as published by the Free Software Foundation. |
||||
|
||||
PerconaFT is distributed in the hope that it will be useful, |
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
GNU General Public License for more details. |
||||
|
||||
You should have received a copy of the GNU General Public License |
||||
along with PerconaFT. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
---------------------------------------- |
||||
|
||||
PerconaFT is free software: you can redistribute it and/or modify |
||||
it under the terms of the GNU Affero General Public License, version 3, |
||||
as published by the Free Software Foundation. |
||||
|
||||
PerconaFT is distributed in the hope that it will be useful, |
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
GNU Affero General Public License for more details. |
||||
|
||||
You should have received a copy of the GNU Affero General Public License |
||||
along with PerconaFT. If not, see <http://www.gnu.org/licenses/>.
|
||||
======= */ |
||||
|
||||
#ident \ |
||||
"Copyright (c) 2006, 2015, Percona and/or its affiliates. All rights reserved." |
||||
|
||||
#include "memarena.h" |
||||
|
||||
#include <string.h> |
||||
|
||||
#include <algorithm> |
||||
|
||||
#include "../portability/memory.h" |
||||
|
||||
void memarena::create(size_t initial_size) { |
||||
_current_chunk = arena_chunk(); |
||||
_other_chunks = nullptr; |
||||
_size_of_other_chunks = 0; |
||||
_footprint_of_other_chunks = 0; |
||||
_n_other_chunks = 0; |
||||
|
||||
_current_chunk.size = initial_size; |
||||
if (_current_chunk.size > 0) { |
||||
XMALLOC_N(_current_chunk.size, _current_chunk.buf); |
||||
} |
||||
} |
||||
|
||||
void memarena::destroy(void) { |
||||
if (_current_chunk.buf) { |
||||
toku_free(_current_chunk.buf); |
||||
} |
||||
for (int i = 0; i < _n_other_chunks; i++) { |
||||
toku_free(_other_chunks[i].buf); |
||||
} |
||||
if (_other_chunks) { |
||||
toku_free(_other_chunks); |
||||
} |
||||
_current_chunk = arena_chunk(); |
||||
_other_chunks = nullptr; |
||||
_n_other_chunks = 0; |
||||
} |
||||
|
||||
static size_t round_to_page(size_t size) { |
||||
const size_t page_size = 4096; |
||||
const size_t r = page_size + ((size - 1) & ~(page_size - 1)); |
||||
assert((r & (page_size - 1)) == 0); // make sure it's aligned
|
||||
assert(r >= size); // make sure it's not too small
|
||||
assert(r < |
||||
size + page_size); // make sure we didn't grow by more than a page.
|
||||
return r; |
||||
} |
||||
|
||||
static const size_t MEMARENA_MAX_CHUNK_SIZE = 64 * 1024 * 1024; |
||||
|
||||
void *memarena::malloc_from_arena(size_t size) { |
||||
if (_current_chunk.buf == nullptr || |
||||
_current_chunk.size < _current_chunk.used + size) { |
||||
// The existing block isn't big enough.
|
||||
// Add the block to the vector of blocks.
|
||||
if (_current_chunk.buf) { |
||||
invariant(_current_chunk.size > 0); |
||||
int old_n = _n_other_chunks; |
||||
XREALLOC_N(old_n + 1, _other_chunks); |
||||
_other_chunks[old_n] = _current_chunk; |
||||
_n_other_chunks = old_n + 1; |
||||
_size_of_other_chunks += _current_chunk.size; |
||||
_footprint_of_other_chunks += |
||||
toku_memory_footprint(_current_chunk.buf, _current_chunk.used); |
||||
} |
||||
|
||||
// Make a new one. Grow the buffer size exponentially until we hit
|
||||
// the max chunk size, but make it at least `size' bytes so the
|
||||
// current allocation always fit.
|
||||
size_t new_size = |
||||
std::min(MEMARENA_MAX_CHUNK_SIZE, 2 * _current_chunk.size); |
||||
if (new_size < size) { |
||||
new_size = size; |
||||
} |
||||
new_size = round_to_page( |
||||
new_size); // at least size, but round to the next page size
|
||||
XMALLOC_N(new_size, _current_chunk.buf); |
||||
_current_chunk.used = 0; |
||||
_current_chunk.size = new_size; |
||||
} |
||||
invariant(_current_chunk.buf != nullptr); |
||||
|
||||
// allocate in the existing block.
|
||||
char *p = _current_chunk.buf + _current_chunk.used; |
||||
_current_chunk.used += size; |
||||
return p; |
||||
} |
||||
|
||||
void memarena::move_memory(memarena *dest) { |
||||
// Move memory to dest
|
||||
XREALLOC_N(dest->_n_other_chunks + _n_other_chunks + 1, dest->_other_chunks); |
||||
dest->_size_of_other_chunks += _size_of_other_chunks + _current_chunk.size; |
||||
dest->_footprint_of_other_chunks += |
||||
_footprint_of_other_chunks + |
||||
toku_memory_footprint(_current_chunk.buf, _current_chunk.used); |
||||
for (int i = 0; i < _n_other_chunks; i++) { |
||||
dest->_other_chunks[dest->_n_other_chunks++] = _other_chunks[i]; |
||||
} |
||||
dest->_other_chunks[dest->_n_other_chunks++] = _current_chunk; |
||||
|
||||
// Clear out this memarena's memory
|
||||
toku_free(_other_chunks); |
||||
_current_chunk = arena_chunk(); |
||||
_other_chunks = nullptr; |
||||
_size_of_other_chunks = 0; |
||||
_footprint_of_other_chunks = 0; |
||||
_n_other_chunks = 0; |
||||
} |
||||
|
||||
size_t memarena::total_memory_size(void) const { |
||||
return sizeof(*this) + total_size_in_use() + |
||||
_n_other_chunks * sizeof(*_other_chunks); |
||||
} |
||||
|
||||
size_t memarena::total_size_in_use(void) const { |
||||
return _size_of_other_chunks + _current_chunk.used; |
||||
} |
||||
|
||||
size_t memarena::total_footprint(void) const { |
||||
return sizeof(*this) + _footprint_of_other_chunks + |
||||
toku_memory_footprint(_current_chunk.buf, _current_chunk.used) + |
||||
_n_other_chunks * sizeof(*_other_chunks); |
||||
} |
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
const void *memarena::chunk_iterator::current(size_t *used) const { |
||||
if (_chunk_idx < 0) { |
||||
*used = _ma->_current_chunk.used; |
||||
return _ma->_current_chunk.buf; |
||||
} else if (_chunk_idx < _ma->_n_other_chunks) { |
||||
*used = _ma->_other_chunks[_chunk_idx].used; |
||||
return _ma->_other_chunks[_chunk_idx].buf; |
||||
} |
||||
*used = 0; |
||||
return nullptr; |
||||
} |
||||
|
||||
void memarena::chunk_iterator::next() { _chunk_idx++; } |
||||
|
||||
bool memarena::chunk_iterator::more() const { |
||||
if (_chunk_idx < 0) { |
||||
return _ma->_current_chunk.buf != nullptr; |
||||
} |
||||
return _chunk_idx < _ma->_n_other_chunks; |
||||
} |
||||
#endif // OS_WIN
|
||||
#endif // ROCKSDB_LITE
|
||||
@ -0,0 +1,127 @@ |
||||
/* -*- mode: C++; c-basic-offset: 4; indent-tabs-mode: nil -*- */ |
||||
// vim: ft=cpp:expandtab:ts=8:sw=4:softtabstop=4:
|
||||
#ident "$Id$" |
||||
/*======
|
||||
This file is part of PerconaFT. |
||||
|
||||
|
||||
Copyright (c) 2006, 2015, Percona and/or its affiliates. All rights reserved. |
||||
|
||||
PerconaFT is free software: you can redistribute it and/or modify |
||||
it under the terms of the GNU General Public License, version 2, |
||||
as published by the Free Software Foundation. |
||||
|
||||
PerconaFT is distributed in the hope that it will be useful, |
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
GNU General Public License for more details. |
||||
|
||||
You should have received a copy of the GNU General Public License |
||||
along with PerconaFT. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
---------------------------------------- |
||||
|
||||
PerconaFT is free software: you can redistribute it and/or modify |
||||
it under the terms of the GNU Affero General Public License, version 3, |
||||
as published by the Free Software Foundation. |
||||
|
||||
PerconaFT is distributed in the hope that it will be useful, |
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
GNU Affero General Public License for more details. |
||||
|
||||
You should have received a copy of the GNU Affero General Public License |
||||
along with PerconaFT. If not, see <http://www.gnu.org/licenses/>.
|
||||
======= */ |
||||
|
||||
#ident \ |
||||
"Copyright (c) 2006, 2015, Percona and/or its affiliates. All rights reserved." |
||||
|
||||
#pragma once |
||||
|
||||
#include <stdlib.h> |
||||
|
||||
/*
|
||||
* A memarena is used to efficiently store a collection of objects that never |
||||
* move The pattern is allocate more and more stuff and free all of the items at |
||||
* once. The underlying memory will store 1 or more objects per chunk. Each |
||||
* chunk is contiguously laid out in memory but chunks are not necessarily |
||||
* contiguous with each other. |
||||
*/ |
||||
class memarena { |
||||
public: |
||||
memarena() |
||||
: _current_chunk(arena_chunk()), |
||||
_other_chunks(nullptr), |
||||
_n_other_chunks(0), |
||||
_size_of_other_chunks(0), |
||||
_footprint_of_other_chunks(0) {} |
||||
|
||||
// Effect: Create a memarena with the specified initial size
|
||||
void create(size_t initial_size); |
||||
|
||||
void destroy(void); |
||||
|
||||
// Effect: Allocate some memory. The returned value remains valid until the
|
||||
// memarena is cleared or closed.
|
||||
// In case of ENOMEM, aborts.
|
||||
void *malloc_from_arena(size_t size); |
||||
|
||||
// Effect: Move all the memory from this memarena into DEST.
|
||||
// When SOURCE is closed the memory won't be freed.
|
||||
// When DEST is closed, the memory will be freed, unless DEST moves
|
||||
// its memory to another memarena...
|
||||
void move_memory(memarena *dest); |
||||
|
||||
// Effect: Calculate the amount of memory used by a memory arena.
|
||||
size_t total_memory_size(void) const; |
||||
|
||||
// Effect: Calculate the used space of the memory arena (ie: excludes unused
|
||||
// space)
|
||||
size_t total_size_in_use(void) const; |
||||
|
||||
// Effect: Calculate the amount of memory used, according to
|
||||
// toku_memory_footprint(),
|
||||
// which is a more expensive but more accurate count of memory used.
|
||||
size_t total_footprint(void) const; |
||||
|
||||
// iterator over the underlying chunks that store objects in the memarena.
|
||||
// a chunk is represented by a pointer to const memory and a usable byte
|
||||
// count.
|
||||
class chunk_iterator { |
||||
public: |
||||
chunk_iterator(const memarena *ma) : _ma(ma), _chunk_idx(-1) {} |
||||
|
||||
// returns: base pointer to the current chunk
|
||||
// *used set to the number of usable bytes
|
||||
// if more() is false, returns nullptr and *used = 0
|
||||
const void *current(size_t *used) const; |
||||
|
||||
// requires: more() is true
|
||||
void next(); |
||||
|
||||
bool more() const; |
||||
|
||||
private: |
||||
// -1 represents the 'initial' chunk in a memarena, ie: ma->_current_chunk
|
||||
// >= 0 represents the i'th chunk in the ma->_other_chunks array
|
||||
const memarena *_ma; |
||||
int _chunk_idx; |
||||
}; |
||||
|
||||
private: |
||||
struct arena_chunk { |
||||
arena_chunk() : buf(nullptr), used(0), size(0) {} |
||||
char *buf; |
||||
size_t used; |
||||
size_t size; |
||||
}; |
||||
|
||||
struct arena_chunk _current_chunk; |
||||
struct arena_chunk *_other_chunks; |
||||
int _n_other_chunks; |
||||
size_t _size_of_other_chunks; // the buf_size of all the other chunks.
|
||||
size_t _footprint_of_other_chunks; // the footprint of all the other chunks.
|
||||
|
||||
friend class memarena_unit_test; |
||||
}; |
||||
@ -0,0 +1,793 @@ |
||||
/* -*- mode: C++; c-basic-offset: 4; indent-tabs-mode: nil -*- */ |
||||
// vim: ft=cpp:expandtab:ts=8:sw=4:softtabstop=4:
|
||||
#ident "$Id$" |
||||
/*======
|
||||
This file is part of PerconaFT. |
||||
|
||||
|
||||
Copyright (c) 2006, 2015, Percona and/or its affiliates. All rights reserved. |
||||
|
||||
PerconaFT is free software: you can redistribute it and/or modify |
||||
it under the terms of the GNU General Public License, version 2, |
||||
as published by the Free Software Foundation. |
||||
|
||||
PerconaFT is distributed in the hope that it will be useful, |
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
GNU General Public License for more details. |
||||
|
||||
You should have received a copy of the GNU General Public License |
||||
along with PerconaFT. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
---------------------------------------- |
||||
|
||||
PerconaFT is free software: you can redistribute it and/or modify |
||||
it under the terms of the GNU Affero General Public License, version 3, |
||||
as published by the Free Software Foundation. |
||||
|
||||
PerconaFT is distributed in the hope that it will be useful, |
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
GNU Affero General Public License for more details. |
||||
|
||||
You should have received a copy of the GNU Affero General Public License |
||||
along with PerconaFT. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
---------------------------------------- |
||||
|
||||
Licensed under the Apache License, Version 2.0 (the "License"); |
||||
you may not use this file except in compliance with the License. |
||||
You may obtain a copy of the License at |
||||
|
||||
http://www.apache.org/licenses/LICENSE-2.0
|
||||
|
||||
Unless required by applicable law or agreed to in writing, software |
||||
distributed under the License is distributed on an "AS IS" BASIS, |
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
||||
See the License for the specific language governing permissions and |
||||
======= */ |
||||
|
||||
#ident \ |
||||
"Copyright (c) 2006, 2015, Percona and/or its affiliates. All rights reserved." |
||||
|
||||
#pragma once |
||||
|
||||
#include <memory.h> |
||||
#include <stdint.h> |
||||
|
||||
#include "../portability/toku_portability.h" |
||||
#include "../portability/toku_race_tools.h" |
||||
#include "growable_array.h" |
||||
|
||||
namespace toku { |
||||
|
||||
/**
|
||||
* Order Maintenance Tree (OMT) |
||||
* |
||||
* Maintains a collection of totally ordered values, where each value has an |
||||
* integer weight. The OMT is a mutable datatype. |
||||
* |
||||
* The Abstraction: |
||||
* |
||||
* An OMT is a vector of values, $V$, where $|V|$ is the length of the vector. |
||||
* The vector is numbered from $0$ to $|V|-1$. |
||||
* Each value has a weight. The weight of the $i$th element is denoted |
||||
* $w(V_i)$. |
||||
* |
||||
* We can create a new OMT, which is the empty vector. |
||||
* |
||||
* We can insert a new element $x$ into slot $i$, changing $V$ into $V'$ where |
||||
* $|V'|=1+|V|$ and |
||||
* |
||||
* V'_j = V_j if $j<i$ |
||||
* x if $j=i$ |
||||
* V_{j-1} if $j>i$. |
||||
* |
||||
* We can specify $i$ using a kind of function instead of as an integer. |
||||
* Let $b$ be a function mapping from values to nonzero integers, such that |
||||
* the signum of $b$ is monotically increasing. |
||||
* We can specify $i$ as the minimum integer such that $b(V_i)>0$. |
||||
* |
||||
* We look up a value using its index, or using a Heaviside function. |
||||
* For lookups, we allow $b$ to be zero for some values, and again the signum of |
||||
* $b$ must be monotonically increasing. When lookup up values, we can look up |
||||
* $V_i$ where $i$ is the minimum integer such that $b(V_i)=0$. (With a |
||||
* special return code if no such value exists.) (Rationale: Ordinarily we want |
||||
* $i$ to be unique. But for various reasons we want to allow multiple zeros, |
||||
* and we want the smallest $i$ in that case.) $V_i$ where $i$ is the minimum |
||||
* integer such that $b(V_i)>0$. (Or an indication that no such value exists.) |
||||
* $V_i$ where $i$ is the maximum integer such that $b(V_i)<0$. (Or an |
||||
* indication that no such value exists.) |
||||
* |
||||
* When looking up a value using a Heaviside function, we get the value and its |
||||
* index. |
||||
* |
||||
* We can also split an OMT into two OMTs, splitting the weight of the values |
||||
* evenly. Find a value $j$ such that the values to the left of $j$ have about |
||||
* the same total weight as the values to the right of $j$. The resulting two |
||||
* OMTs contain the values to the left of $j$ and the values to the right of $j$ |
||||
* respectively. All of the values from the original OMT go into one of the new |
||||
* OMTs. If the weights of the values don't split exactly evenly, then the |
||||
* implementation has the freedom to choose whether the new left OMT or the new |
||||
* right OMT is larger. |
||||
* |
||||
* Performance: |
||||
* Insertion and deletion should run with $O(\log |V|)$ time and $O(\log |V|)$ |
||||
* calls to the Heaviside function. The memory required is O(|V|). |
||||
* |
||||
* Usage: |
||||
* The omt is templated by two parameters: |
||||
* - omtdata_t is what will be stored within the omt. These could be pointers |
||||
* or real data types (ints, structs). |
||||
* - omtdataout_t is what will be returned by find and related functions. By |
||||
* default, it is the same as omtdata_t, but you can set it to (omtdata_t *). To |
||||
* create an omt which will store "TXNID"s, for example, it is a good idea to |
||||
* typedef the template: typedef omt<TXNID> txnid_omt_t; If you are storing |
||||
* structs, you may want to be able to get a pointer to the data actually stored |
||||
* in the omt (see find_zero). To do this, use the second template parameter: |
||||
* typedef omt<struct foo, struct foo *> foo_omt_t; |
||||
*/ |
||||
|
||||
namespace omt_internal { |
||||
|
||||
template <bool subtree_supports_marks> |
||||
class subtree_templated { |
||||
private: |
||||
uint32_t m_index; |
||||
|
||||
public: |
||||
static const uint32_t NODE_NULL = UINT32_MAX; |
||||
inline void set_to_null(void) { m_index = NODE_NULL; } |
||||
|
||||
inline bool is_null(void) const { return NODE_NULL == this->get_index(); } |
||||
|
||||
inline uint32_t get_index(void) const { return m_index; } |
||||
|
||||
inline void set_index(uint32_t index) { |
||||
paranoid_invariant(index != NODE_NULL); |
||||
m_index = index; |
||||
} |
||||
} __attribute__((__packed__, aligned(4))); |
||||
|
||||
template <> |
||||
class subtree_templated<true> { |
||||
private: |
||||
uint32_t m_bitfield; |
||||
static const uint32_t MASK_INDEX = ~(((uint32_t)1) << 31); |
||||
static const uint32_t MASK_BIT = ((uint32_t)1) << 31; |
||||
|
||||
inline void set_index_internal(uint32_t new_index) { |
||||
m_bitfield = (m_bitfield & MASK_BIT) | new_index; |
||||
} |
||||
|
||||
public: |
||||
static const uint32_t NODE_NULL = INT32_MAX; |
||||
inline void set_to_null(void) { this->set_index_internal(NODE_NULL); } |
||||
|
||||
inline bool is_null(void) const { return NODE_NULL == this->get_index(); } |
||||
|
||||
inline uint32_t get_index(void) const { |
||||
TOKU_DRD_IGNORE_VAR(m_bitfield); |
||||
const uint32_t bits = m_bitfield; |
||||
TOKU_DRD_STOP_IGNORING_VAR(m_bitfield); |
||||
return bits & MASK_INDEX; |
||||
} |
||||
|
||||
inline void set_index(uint32_t index) { |
||||
paranoid_invariant(index < NODE_NULL); |
||||
this->set_index_internal(index); |
||||
} |
||||
|
||||
inline bool get_bit(void) const { |
||||
TOKU_DRD_IGNORE_VAR(m_bitfield); |
||||
const uint32_t bits = m_bitfield; |
||||
TOKU_DRD_STOP_IGNORING_VAR(m_bitfield); |
||||
return (bits & MASK_BIT) != 0; |
||||
} |
||||
|
||||
inline void enable_bit(void) { |
||||
// These bits may be set by a thread with a write lock on some
|
||||
// leaf, and the index can be read by another thread with a (read
|
||||
// or write) lock on another thread. Also, the has_marks_below
|
||||
// bit can be set by two threads simultaneously. Neither of these
|
||||
// are real races, so if we are using DRD we should tell it to
|
||||
// ignore these bits just while we set this bit. If there were a
|
||||
// race in setting the index, that would be a real race.
|
||||
TOKU_DRD_IGNORE_VAR(m_bitfield); |
||||
m_bitfield |= MASK_BIT; |
||||
TOKU_DRD_STOP_IGNORING_VAR(m_bitfield); |
||||
} |
||||
|
||||
inline void disable_bit(void) { m_bitfield &= MASK_INDEX; } |
||||
} __attribute__((__packed__)); |
||||
|
||||
template <typename omtdata_t, bool subtree_supports_marks> |
||||
class omt_node_templated { |
||||
public: |
||||
omtdata_t value; |
||||
uint32_t weight; |
||||
subtree_templated<subtree_supports_marks> left; |
||||
subtree_templated<subtree_supports_marks> right; |
||||
|
||||
// this needs to be in both implementations because we don't have
|
||||
// a "static if" the caller can use
|
||||
inline void clear_stolen_bits(void) {} |
||||
}; // note: originally this class had __attribute__((__packed__, aligned(4)))
|
||||
|
||||
template <typename omtdata_t> |
||||
class omt_node_templated<omtdata_t, true> { |
||||
public: |
||||
omtdata_t value; |
||||
uint32_t weight; |
||||
subtree_templated<true> left; |
||||
subtree_templated<true> right; |
||||
inline bool get_marked(void) const { return left.get_bit(); } |
||||
inline void set_marked_bit(void) { return left.enable_bit(); } |
||||
inline void unset_marked_bit(void) { return left.disable_bit(); } |
||||
|
||||
inline bool get_marks_below(void) const { return right.get_bit(); } |
||||
inline void set_marks_below_bit(void) { |
||||
// This function can be called by multiple threads.
|
||||
// Checking first reduces cache invalidation.
|
||||
if (!this->get_marks_below()) { |
||||
right.enable_bit(); |
||||
} |
||||
} |
||||
inline void unset_marks_below_bit(void) { right.disable_bit(); } |
||||
|
||||
inline void clear_stolen_bits(void) { |
||||
this->unset_marked_bit(); |
||||
this->unset_marks_below_bit(); |
||||
} |
||||
}; // note: originally this class had __attribute__((__packed__, aligned(4)))
|
||||
|
||||
} // namespace omt_internal
|
||||
|
||||
template <typename omtdata_t, typename omtdataout_t = omtdata_t, |
||||
bool supports_marks = false> |
||||
class omt { |
||||
public: |
||||
/**
|
||||
* Effect: Create an empty OMT. |
||||
* Performance: constant time. |
||||
*/ |
||||
void create(void); |
||||
|
||||
/**
|
||||
* Effect: Create an empty OMT with no internal allocated space. |
||||
* Performance: constant time. |
||||
* Rationale: In some cases we need a valid omt but don't want to malloc. |
||||
*/ |
||||
void create_no_array(void); |
||||
|
||||
/**
|
||||
* Effect: Create a OMT containing values. The number of values is in |
||||
* numvalues. Stores the new OMT in *omtp. Requires: this has not been created |
||||
* yet Requires: values != NULL Requires: values is sorted Performance: |
||||
* time=O(numvalues) Rationale: Normally to insert N values takes O(N lg N) |
||||
* amortized time. If the N values are known in advance, are sorted, and the |
||||
* structure is empty, we can batch insert them much faster. |
||||
*/ |
||||
__attribute__((nonnull)) void create_from_sorted_array( |
||||
const omtdata_t *const values, const uint32_t numvalues); |
||||
|
||||
/**
|
||||
* Effect: Create an OMT containing values. The number of values is in |
||||
* numvalues. On success the OMT takes ownership of *values array, and sets |
||||
* values=NULL. Requires: this has not been created yet Requires: values != |
||||
* NULL Requires: *values is sorted Requires: *values was allocated with |
||||
* toku_malloc Requires: Capacity of the *values array is <= new_capacity |
||||
* Requires: On success, *values may not be accessed again by the caller. |
||||
* Performance: time=O(1) |
||||
* Rational: create_from_sorted_array takes O(numvalues) time. |
||||
* By taking ownership of the array, we save a malloc and |
||||
* memcpy, and possibly a free (if the caller is done with the array). |
||||
*/ |
||||
void create_steal_sorted_array(omtdata_t **const values, |
||||
const uint32_t numvalues, |
||||
const uint32_t new_capacity); |
||||
|
||||
/**
|
||||
* Effect: Create a new OMT, storing it in *newomt. |
||||
* The values to the right of index (starting at index) are moved to *newomt. |
||||
* Requires: newomt != NULL |
||||
* Returns |
||||
* 0 success, |
||||
* EINVAL if index > toku_omt_size(omt) |
||||
* On nonzero return, omt and *newomt are unmodified. |
||||
* Performance: time=O(n) |
||||
* Rationale: We don't need a split-evenly operation. We need to split items |
||||
* so that their total sizes are even, and other similar splitting criteria. |
||||
* It's easy to split evenly by calling size(), and dividing by two. |
||||
*/ |
||||
__attribute__((nonnull)) int split_at(omt *const newomt, const uint32_t idx); |
||||
|
||||
/**
|
||||
* Effect: Appends leftomt and rightomt to produce a new omt. |
||||
* Creates this as the new omt. |
||||
* leftomt and rightomt are destroyed. |
||||
* Performance: time=O(n) is acceptable, but one can imagine implementations |
||||
* that are O(\log n) worst-case. |
||||
*/ |
||||
__attribute__((nonnull)) void merge(omt *const leftomt, omt *const rightomt); |
||||
|
||||
/**
|
||||
* Effect: Creates a copy of an omt. |
||||
* Creates this as the clone. |
||||
* Each element is copied directly. If they are pointers, the underlying |
||||
* data is not duplicated. Performance: O(n) or the running time of |
||||
* fill_array_with_subtree_values() |
||||
*/ |
||||
void clone(const omt &src); |
||||
|
||||
/**
|
||||
* Effect: Set the tree to be empty. |
||||
* Note: Will not reallocate or resize any memory. |
||||
* Performance: time=O(1) |
||||
*/ |
||||
void clear(void); |
||||
|
||||
/**
|
||||
* Effect: Destroy an OMT, freeing all its memory. |
||||
* If the values being stored are pointers, their underlying data is not |
||||
* freed. See free_items() Those values may be freed before or after calling |
||||
* toku_omt_destroy. Rationale: Returns no values since free() cannot fail. |
||||
* Rationale: Does not free the underlying pointers to reduce complexity. |
||||
* Performance: time=O(1) |
||||
*/ |
||||
void destroy(void); |
||||
|
||||
/**
|
||||
* Effect: return |this|. |
||||
* Performance: time=O(1) |
||||
*/ |
||||
uint32_t size(void) const; |
||||
|
||||
/**
|
||||
* Effect: Insert value into the OMT. |
||||
* If there is some i such that $h(V_i, v)=0$ then returns DB_KEYEXIST. |
||||
* Otherwise, let i be the minimum value such that $h(V_i, v)>0$. |
||||
* If no such i exists, then let i be |V| |
||||
* Then this has the same effect as |
||||
* insert_at(tree, value, i); |
||||
* If idx!=NULL then i is stored in *idx |
||||
* Requires: The signum of h must be monotonically increasing. |
||||
* Returns: |
||||
* 0 success |
||||
* DB_KEYEXIST the key is present (h was equal to zero for some value) |
||||
* On nonzero return, omt is unchanged. |
||||
* Performance: time=O(\log N) amortized. |
||||
* Rationale: Some future implementation may be O(\log N) worst-case time, but |
||||
* O(\log N) amortized is good enough for now. |
||||
*/ |
||||
template <typename omtcmp_t, int (*h)(const omtdata_t &, const omtcmp_t &)> |
||||
int insert(const omtdata_t &value, const omtcmp_t &v, uint32_t *const idx); |
||||
|
||||
/**
|
||||
* Effect: Increases indexes of all items at slot >= idx by 1. |
||||
* Insert value into the position at idx. |
||||
* Returns: |
||||
* 0 success |
||||
* EINVAL if idx > this->size() |
||||
* On error, omt is unchanged. |
||||
* Performance: time=O(\log N) amortized time. |
||||
* Rationale: Some future implementation may be O(\log N) worst-case time, but |
||||
* O(\log N) amortized is good enough for now. |
||||
*/ |
||||
int insert_at(const omtdata_t &value, const uint32_t idx); |
||||
|
||||
/**
|
||||
* Effect: Replaces the item at idx with value. |
||||
* Returns: |
||||
* 0 success |
||||
* EINVAL if idx>=this->size() |
||||
* On error, omt is unchanged. |
||||
* Performance: time=O(\log N) |
||||
* Rationale: The FT needs to be able to replace a value with another copy of |
||||
* the same value (allocated in a different location) |
||||
* |
||||
*/ |
||||
int set_at(const omtdata_t &value, const uint32_t idx); |
||||
|
||||
/**
|
||||
* Effect: Delete the item in slot idx. |
||||
* Decreases indexes of all items at slot > idx by 1. |
||||
* Returns |
||||
* 0 success |
||||
* EINVAL if idx>=this->size() |
||||
* On error, omt is unchanged. |
||||
* Rationale: To delete an item, first find its index using find or find_zero, |
||||
* then delete it. Performance: time=O(\log N) amortized. |
||||
*/ |
||||
int delete_at(const uint32_t idx); |
||||
|
||||
/**
|
||||
* Effect: Iterate over the values of the omt, from left to right, calling f |
||||
* on each value. The first argument passed to f is a ref-to-const of the |
||||
* value stored in the omt. The second argument passed to f is the index of |
||||
* the value. The third argument passed to f is iterate_extra. The indices run |
||||
* from 0 (inclusive) to this->size() (exclusive). Requires: f != NULL |
||||
* Returns: |
||||
* If f ever returns nonzero, then the iteration stops, and the value |
||||
* returned by f is returned by iterate. If f always returns zero, then |
||||
* iterate returns 0. Requires: Don't modify the omt while running. (E.g., f |
||||
* may not insert or delete values from the omt.) Performance: time=O(i+\log |
||||
* N) where i is the number of times f is called, and N is the number of |
||||
* elements in the omt. Rationale: Although the functional iterator requires |
||||
* defining another function (as opposed to C++ style iterator), it is much |
||||
* easier to read. Rationale: We may at some point use functors, but for now |
||||
* this is a smaller change from the old OMT. |
||||
*/ |
||||
template <typename iterate_extra_t, |
||||
int (*f)(const omtdata_t &, const uint32_t, iterate_extra_t *const)> |
||||
int iterate(iterate_extra_t *const iterate_extra) const; |
||||
|
||||
/**
|
||||
* Effect: Iterate over the values of the omt, from left to right, calling f |
||||
* on each value. The first argument passed to f is a ref-to-const of the |
||||
* value stored in the omt. The second argument passed to f is the index of |
||||
* the value. The third argument passed to f is iterate_extra. The indices run |
||||
* from 0 (inclusive) to this->size() (exclusive). We will iterate only over |
||||
* [left,right) |
||||
* |
||||
* Requires: left <= right |
||||
* Requires: f != NULL |
||||
* Returns: |
||||
* EINVAL if right > this->size() |
||||
* If f ever returns nonzero, then the iteration stops, and the value |
||||
* returned by f is returned by iterate_on_range. If f always returns zero, |
||||
* then iterate_on_range returns 0. Requires: Don't modify the omt while |
||||
* running. (E.g., f may not insert or delete values from the omt.) |
||||
* Performance: time=O(i+\log N) where i is the number of times f is called, |
||||
* and N is the number of elements in the omt. Rational: Although the |
||||
* functional iterator requires defining another function (as opposed to C++ |
||||
* style iterator), it is much easier to read. |
||||
*/ |
||||
template <typename iterate_extra_t, |
||||
int (*f)(const omtdata_t &, const uint32_t, iterate_extra_t *const)> |
||||
int iterate_on_range(const uint32_t left, const uint32_t right, |
||||
iterate_extra_t *const iterate_extra) const; |
||||
|
||||
/**
|
||||
* Effect: Iterate over the values of the omt, and mark the nodes that are |
||||
* visited. Other than the marks, this behaves the same as iterate_on_range. |
||||
* Requires: supports_marks == true |
||||
* Performance: time=O(i+\log N) where i is the number of times f is called, |
||||
* and N is the number of elements in the omt. Notes: This function MAY be |
||||
* called concurrently by multiple threads, but not concurrently with any |
||||
* other non-const function. |
||||
*/ |
||||
template <typename iterate_extra_t, |
||||
int (*f)(const omtdata_t &, const uint32_t, iterate_extra_t *const)> |
||||
int iterate_and_mark_range(const uint32_t left, const uint32_t right, |
||||
iterate_extra_t *const iterate_extra); |
||||
|
||||
/**
|
||||
* Effect: Iterate over the values of the omt, from left to right, calling f |
||||
* on each value whose node has been marked. Other than the marks, this |
||||
* behaves the same as iterate. Requires: supports_marks == true Performance: |
||||
* time=O(i+\log N) where i is the number of times f is called, and N is the |
||||
* number of elements in the omt. |
||||
*/ |
||||
template <typename iterate_extra_t, |
||||
int (*f)(const omtdata_t &, const uint32_t, iterate_extra_t *const)> |
||||
int iterate_over_marked(iterate_extra_t *const iterate_extra) const; |
||||
|
||||
/**
|
||||
* Effect: Delete all elements from the omt, whose nodes have been marked. |
||||
* Requires: supports_marks == true |
||||
* Performance: time=O(N + i\log N) where i is the number of marked elements, |
||||
* {c,sh}ould be faster |
||||
*/ |
||||
void delete_all_marked(void); |
||||
|
||||
/**
|
||||
* Effect: Verify that the internal state of the marks in the tree are |
||||
* self-consistent. Crashes the system if the marks are in a bad state. |
||||
* Requires: supports_marks == true |
||||
* Performance: time=O(N) |
||||
* Notes: |
||||
* Even though this is a const function, it requires exclusive access. |
||||
* Rationale: |
||||
* The current implementation of the marks relies on a sort of |
||||
* "cache" bit representing the state of bits below it in the tree. |
||||
* This allows glass-box testing that these bits are correct. |
||||
*/ |
||||
void verify_marks_consistent(void) const; |
||||
|
||||
/**
|
||||
* Effect: None |
||||
* Returns whether there are any marks in the tree. |
||||
*/ |
||||
bool has_marks(void) const; |
||||
|
||||
/**
|
||||
* Effect: Iterate over the values of the omt, from left to right, calling f |
||||
* on each value. The first argument passed to f is a pointer to the value |
||||
* stored in the omt. The second argument passed to f is the index of the |
||||
* value. The third argument passed to f is iterate_extra. The indices run |
||||
* from 0 (inclusive) to this->size() (exclusive). Requires: same as for |
||||
* iterate() Returns: same as for iterate() Performance: same as for iterate() |
||||
* Rationale: In general, most iterators should use iterate() since they |
||||
* should not modify the data stored in the omt. This function is for |
||||
* iterators which need to modify values (for example, free_items). Rationale: |
||||
* We assume if you are transforming the data in place, you want to do it to |
||||
* everything at once, so there is not yet an iterate_on_range_ptr (but there |
||||
* could be). |
||||
*/ |
||||
template <typename iterate_extra_t, |
||||
int (*f)(omtdata_t *, const uint32_t, iterate_extra_t *const)> |
||||
void iterate_ptr(iterate_extra_t *const iterate_extra); |
||||
|
||||
/**
|
||||
* Effect: Set *value=V_idx |
||||
* Returns |
||||
* 0 success |
||||
* EINVAL if index>=toku_omt_size(omt) |
||||
* On nonzero return, *value is unchanged |
||||
* Performance: time=O(\log N) |
||||
*/ |
||||
int fetch(const uint32_t idx, omtdataout_t *const value) const; |
||||
|
||||
/**
|
||||
* Effect: Find the smallest i such that h(V_i, extra)>=0 |
||||
* If there is such an i and h(V_i,extra)==0 then set *idxp=i, set *value = |
||||
* V_i, and return 0. If there is such an i and h(V_i,extra)>0 then set |
||||
* *idxp=i and return DB_NOTFOUND. If there is no such i then set |
||||
* *idx=this->size() and return DB_NOTFOUND. Note: value is of type |
||||
* omtdataout_t, which may be of type (omtdata_t) or (omtdata_t *) but is |
||||
* fixed by the instantiation. If it is the value type, then the value is |
||||
* copied out (even if the value type is a pointer to something else) If it is |
||||
* the pointer type, then *value is set to a pointer to the data within the |
||||
* omt. This is determined by the type of the omt as initially declared. If |
||||
* the omt is declared as omt<foo_t>, then foo_t's will be stored and foo_t's |
||||
* will be returned by find and related functions. If the omt is declared as |
||||
* omt<foo_t, foo_t *>, then foo_t's will be stored, and pointers to the |
||||
* stored items will be returned by find and related functions. Rationale: |
||||
* Structs too small for malloc should be stored directly in the omt. |
||||
* These structs may need to be edited as they exist inside the omt, so we |
||||
* need a way to get a pointer within the omt. Using separate functions for |
||||
* returning pointers and values increases code duplication and reduces |
||||
* type-checking. That also reduces the ability of the creator of a data |
||||
* structure to give advice to its future users. Slight overloading in this |
||||
* case seemed to provide a better API and better type checking. |
||||
*/ |
||||
template <typename omtcmp_t, int (*h)(const omtdata_t &, const omtcmp_t &)> |
||||
int find_zero(const omtcmp_t &extra, omtdataout_t *const value, |
||||
uint32_t *const idxp) const; |
||||
|
||||
/**
|
||||
* Effect: |
||||
* If direction >0 then find the smallest i such that h(V_i,extra)>0. |
||||
* If direction <0 then find the largest i such that h(V_i,extra)<0. |
||||
* (Direction may not be equal to zero.) |
||||
* If value!=NULL then store V_i in *value |
||||
* If idxp!=NULL then store i in *idxp. |
||||
* Requires: The signum of h is monotically increasing. |
||||
* Returns |
||||
* 0 success |
||||
* DB_NOTFOUND no such value is found. |
||||
* On nonzero return, *value and *idxp are unchanged |
||||
* Performance: time=O(\log N) |
||||
* Rationale: |
||||
* Here's how to use the find function to find various things |
||||
* Cases for find: |
||||
* find first value: ( h(v)=+1, direction=+1 ) |
||||
* find last value ( h(v)=-1, direction=-1 ) |
||||
* find first X ( h(v)=(v< x) ? -1 : 1 direction=+1 ) |
||||
* find last X ( h(v)=(v<=x) ? -1 : 1 direction=-1 ) |
||||
* find X or successor to X ( same as find first X. ) |
||||
* |
||||
* Rationale: To help understand heaviside functions and behavor of find: |
||||
* There are 7 kinds of heaviside functions. |
||||
* The signus of the h must be monotonically increasing. |
||||
* Given a function of the following form, A is the element |
||||
* returned for direction>0, B is the element returned |
||||
* for direction<0, C is the element returned for |
||||
* direction==0 (see find_zero) (with a return of 0), and D is the element |
||||
* returned for direction==0 (see find_zero) with a return of DB_NOTFOUND. |
||||
* If any of A, B, or C are not found, then asking for the |
||||
* associated direction will return DB_NOTFOUND. |
||||
* See find_zero for more information. |
||||
* |
||||
* Let the following represent the signus of the heaviside function. |
||||
* |
||||
* -...- |
||||
* A |
||||
* D |
||||
* |
||||
* +...+ |
||||
* B |
||||
* D |
||||
* |
||||
* 0...0 |
||||
* C |
||||
* |
||||
* -...-0...0 |
||||
* AC |
||||
* |
||||
* 0...0+...+ |
||||
* C B |
||||
* |
||||
* -...-+...+ |
||||
* AB |
||||
* D |
||||
* |
||||
* -...-0...0+...+ |
||||
* AC B |
||||
*/ |
||||
template <typename omtcmp_t, int (*h)(const omtdata_t &, const omtcmp_t &)> |
||||
int find(const omtcmp_t &extra, int direction, omtdataout_t *const value, |
||||
uint32_t *const idxp) const; |
||||
|
||||
/**
|
||||
* Effect: Return the size (in bytes) of the omt, as it resides in main |
||||
* memory. If the data stored are pointers, don't include the size of what |
||||
* they all point to. |
||||
*/ |
||||
size_t memory_size(void); |
||||
|
||||
private: |
||||
typedef uint32_t node_idx; |
||||
typedef omt_internal::subtree_templated<supports_marks> subtree; |
||||
typedef omt_internal::omt_node_templated<omtdata_t, supports_marks> omt_node; |
||||
ENSURE_POD(subtree); |
||||
|
||||
struct omt_array { |
||||
uint32_t start_idx; |
||||
uint32_t num_values; |
||||
omtdata_t *values; |
||||
}; |
||||
|
||||
struct omt_tree { |
||||
subtree root; |
||||
uint32_t free_idx; |
||||
omt_node *nodes; |
||||
}; |
||||
|
||||
bool is_array; |
||||
uint32_t capacity; |
||||
union { |
||||
struct omt_array a; |
||||
struct omt_tree t; |
||||
} d; |
||||
|
||||
__attribute__((nonnull)) void unmark(const subtree &subtree, |
||||
const uint32_t index, |
||||
GrowableArray<node_idx> *const indexes); |
||||
|
||||
void create_internal_no_array(const uint32_t new_capacity); |
||||
|
||||
void create_internal(const uint32_t new_capacity); |
||||
|
||||
uint32_t nweight(const subtree &subtree) const; |
||||
|
||||
node_idx node_malloc(void); |
||||
|
||||
void node_free(const node_idx idx); |
||||
|
||||
void maybe_resize_array(const uint32_t n); |
||||
|
||||
__attribute__((nonnull)) void fill_array_with_subtree_values( |
||||
omtdata_t *const array, const subtree &subtree) const; |
||||
|
||||
void convert_to_array(void); |
||||
|
||||
__attribute__((nonnull)) void rebuild_from_sorted_array( |
||||
subtree *const subtree, const omtdata_t *const values, |
||||
const uint32_t numvalues); |
||||
|
||||
void convert_to_tree(void); |
||||
|
||||
void maybe_resize_or_convert(const uint32_t n); |
||||
|
||||
bool will_need_rebalance(const subtree &subtree, const int leftmod, |
||||
const int rightmod) const; |
||||
|
||||
__attribute__((nonnull)) void insert_internal( |
||||
subtree *const subtreep, const omtdata_t &value, const uint32_t idx, |
||||
subtree **const rebalance_subtree); |
||||
|
||||
void set_at_internal_array(const omtdata_t &value, const uint32_t idx); |
||||
|
||||
void set_at_internal(const subtree &subtree, const omtdata_t &value, |
||||
const uint32_t idx); |
||||
|
||||
void delete_internal(subtree *const subtreep, const uint32_t idx, |
||||
omt_node *const copyn, |
||||
subtree **const rebalance_subtree); |
||||
|
||||
template <typename iterate_extra_t, |
||||
int (*f)(const omtdata_t &, const uint32_t, iterate_extra_t *const)> |
||||
int iterate_internal_array(const uint32_t left, const uint32_t right, |
||||
iterate_extra_t *const iterate_extra) const; |
||||
|
||||
template <typename iterate_extra_t, |
||||
int (*f)(omtdata_t *, const uint32_t, iterate_extra_t *const)> |
||||
void iterate_ptr_internal(const uint32_t left, const uint32_t right, |
||||
const subtree &subtree, const uint32_t idx, |
||||
iterate_extra_t *const iterate_extra); |
||||
|
||||
template <typename iterate_extra_t, |
||||
int (*f)(omtdata_t *, const uint32_t, iterate_extra_t *const)> |
||||
void iterate_ptr_internal_array(const uint32_t left, const uint32_t right, |
||||
iterate_extra_t *const iterate_extra); |
||||
|
||||
template <typename iterate_extra_t, |
||||
int (*f)(const omtdata_t &, const uint32_t, iterate_extra_t *const)> |
||||
int iterate_internal(const uint32_t left, const uint32_t right, |
||||
const subtree &subtree, const uint32_t idx, |
||||
iterate_extra_t *const iterate_extra) const; |
||||
|
||||
template <typename iterate_extra_t, |
||||
int (*f)(const omtdata_t &, const uint32_t, iterate_extra_t *const)> |
||||
int iterate_and_mark_range_internal(const uint32_t left, const uint32_t right, |
||||
const subtree &subtree, |
||||
const uint32_t idx, |
||||
iterate_extra_t *const iterate_extra); |
||||
|
||||
template <typename iterate_extra_t, |
||||
int (*f)(const omtdata_t &, const uint32_t, iterate_extra_t *const)> |
||||
int iterate_over_marked_internal(const subtree &subtree, const uint32_t idx, |
||||
iterate_extra_t *const iterate_extra) const; |
||||
|
||||
uint32_t verify_marks_consistent_internal(const subtree &subtree, |
||||
const bool allow_marks) const; |
||||
|
||||
void fetch_internal_array(const uint32_t i, omtdataout_t *const value) const; |
||||
|
||||
void fetch_internal(const subtree &subtree, const uint32_t i, |
||||
omtdataout_t *const value) const; |
||||
|
||||
__attribute__((nonnull)) void fill_array_with_subtree_idxs( |
||||
node_idx *const array, const subtree &subtree) const; |
||||
|
||||
__attribute__((nonnull)) void rebuild_subtree_from_idxs( |
||||
subtree *const subtree, const node_idx *const idxs, |
||||
const uint32_t numvalues); |
||||
|
||||
__attribute__((nonnull)) void rebalance(subtree *const subtree); |
||||
|
||||
__attribute__((nonnull)) static void copyout(omtdata_t *const out, |
||||
const omt_node *const n); |
||||
|
||||
__attribute__((nonnull)) static void copyout(omtdata_t **const out, |
||||
omt_node *const n); |
||||
|
||||
__attribute__((nonnull)) static void copyout( |
||||
omtdata_t *const out, const omtdata_t *const stored_value_ptr); |
||||
|
||||
__attribute__((nonnull)) static void copyout( |
||||
omtdata_t **const out, omtdata_t *const stored_value_ptr); |
||||
|
||||
template <typename omtcmp_t, int (*h)(const omtdata_t &, const omtcmp_t &)> |
||||
int find_internal_zero_array(const omtcmp_t &extra, omtdataout_t *const value, |
||||
uint32_t *const idxp) const; |
||||
|
||||
template <typename omtcmp_t, int (*h)(const omtdata_t &, const omtcmp_t &)> |
||||
int find_internal_zero(const subtree &subtree, const omtcmp_t &extra, |
||||
omtdataout_t *const value, uint32_t *const idxp) const; |
||||
|
||||
template <typename omtcmp_t, int (*h)(const omtdata_t &, const omtcmp_t &)> |
||||
int find_internal_plus_array(const omtcmp_t &extra, omtdataout_t *const value, |
||||
uint32_t *const idxp) const; |
||||
|
||||
template <typename omtcmp_t, int (*h)(const omtdata_t &, const omtcmp_t &)> |
||||
int find_internal_plus(const subtree &subtree, const omtcmp_t &extra, |
||||
omtdataout_t *const value, uint32_t *const idxp) const; |
||||
|
||||
template <typename omtcmp_t, int (*h)(const omtdata_t &, const omtcmp_t &)> |
||||
int find_internal_minus_array(const omtcmp_t &extra, |
||||
omtdataout_t *const value, |
||||
uint32_t *const idxp) const; |
||||
|
||||
template <typename omtcmp_t, int (*h)(const omtdata_t &, const omtcmp_t &)> |
||||
int find_internal_minus(const subtree &subtree, const omtcmp_t &extra, |
||||
omtdataout_t *const value, |
||||
uint32_t *const idxp) const; |
||||
}; |
||||
|
||||
} // namespace toku
|
||||
|
||||
// include the implementation here
|
||||
#include "omt_impl.h" |
||||
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,151 @@ |
||||
/* -*- mode: C++; c-basic-offset: 4; indent-tabs-mode: nil -*- */ |
||||
// vim: ft=cpp:expandtab:ts=8:sw=4:softtabstop=4:
|
||||
#ident "$Id$" |
||||
/*======
|
||||
This file is part of PerconaFT. |
||||
|
||||
|
||||
Copyright (c) 2006, 2015, Percona and/or its affiliates. All rights reserved. |
||||
|
||||
PerconaFT is free software: you can redistribute it and/or modify |
||||
it under the terms of the GNU General Public License, version 2, |
||||
as published by the Free Software Foundation. |
||||
|
||||
PerconaFT is distributed in the hope that it will be useful, |
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
GNU General Public License for more details. |
||||
|
||||
You should have received a copy of the GNU General Public License |
||||
along with PerconaFT. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
---------------------------------------- |
||||
|
||||
PerconaFT is free software: you can redistribute it and/or modify |
||||
it under the terms of the GNU Affero General Public License, version 3, |
||||
as published by the Free Software Foundation. |
||||
|
||||
PerconaFT is distributed in the hope that it will be useful, |
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
GNU Affero General Public License for more details. |
||||
|
||||
You should have received a copy of the GNU Affero General Public License |
||||
along with PerconaFT. If not, see <http://www.gnu.org/licenses/>.
|
||||
======= */ |
||||
|
||||
#ident \ |
||||
"Copyright (c) 2006, 2015, Percona and/or its affiliates. All rights reserved." |
||||
|
||||
#pragma once |
||||
|
||||
// Overview: A partitioned_counter provides a counter that can be incremented
|
||||
// and the running sum can be read at any time.
|
||||
// We assume that increments are frequent, whereas reading is infrequent.
|
||||
// Implementation hint: Use thread-local storage so each thread increments its
|
||||
// own data. The increment does not require a lock or atomic operation.
|
||||
// Reading the data can be performed by iterating over the thread-local
|
||||
// versions, summing them up. The data structure also includes a sum for all
|
||||
// the threads that have died. Use a pthread_key to create the thread-local
|
||||
// versions. When a thread finishes, the system calls pthread_key destructor
|
||||
// which can add that thread's copy into the sum_of_dead counter.
|
||||
// Rationale: For statistics such as are found in engine status, we need a
|
||||
// counter that requires no cache misses to increment. We've seen significant
|
||||
// performance speedups by removing certain counters. Rather than removing
|
||||
// those statistics, we would like to just make the counter fast. We generally
|
||||
// increment the counters frequently, and want to fetch the values
|
||||
// infrequently. The counters are monotonic. The counters can be split into
|
||||
// many counters, which can be summed up at the end. We don't care if we get
|
||||
// slightly out-of-date counter sums when we read the counter. We don't care
|
||||
// if there is a race on reading the a counter
|
||||
// variable and incrementing.
|
||||
// See tests/test_partitioned_counter.c for some performance measurements.
|
||||
// Operations:
|
||||
// create_partitioned_counter Create a counter initialized to zero.
|
||||
// destroy_partitioned_counter Destroy it.
|
||||
// increment_partitioned_counter Increment it. This is the frequent
|
||||
// operation. read_partitioned_counter Get the current value. This is
|
||||
// infrequent.
|
||||
// See partitioned_counter.cc for the abstraction function and representation
|
||||
// invariant.
|
||||
//
|
||||
// The google style guide says to avoid using constructors, and it appears that
|
||||
// constructors may have broken all the tests, because they called
|
||||
// pthread_key_create before the key was actually created. So the google style
|
||||
// guide may have some wisdom there...
|
||||
//
|
||||
// This version does not use constructors, essentially reverrting to the google
|
||||
// C++ style guide.
|
||||
//
|
||||
|
||||
// The old C interface. This required a bunch of explicit
|
||||
// ___attribute__((__destructor__)) functions to remember to destroy counters at
|
||||
// the end.
|
||||
#if defined(__cplusplus) |
||||
extern "C" { |
||||
#endif |
||||
|
||||
typedef struct partitioned_counter *PARTITIONED_COUNTER; |
||||
PARTITIONED_COUNTER create_partitioned_counter(void); |
||||
// Effect: Create a counter, initialized to zero.
|
||||
|
||||
void destroy_partitioned_counter(PARTITIONED_COUNTER); |
||||
// Effect: Destroy the counter. No operations on that counter are permitted
|
||||
// after this.
|
||||
|
||||
void increment_partitioned_counter(PARTITIONED_COUNTER, uint64_t amount); |
||||
// Effect: Increment the counter by amount.
|
||||
// Requires: No overflows. This is a 64-bit unsigned counter.
|
||||
|
||||
uint64_t read_partitioned_counter(PARTITIONED_COUNTER) |
||||
__attribute__((__visibility__("default"))); |
||||
// Effect: Return the current value of the counter.
|
||||
|
||||
void partitioned_counters_init(void); |
||||
// Effect: Initialize any partitioned counters data structures that must be set
|
||||
// up before any partitioned counters run.
|
||||
|
||||
void partitioned_counters_destroy(void); |
||||
// Effect: Destroy any partitioned counters data structures.
|
||||
|
||||
#if defined(__cplusplus) |
||||
}; |
||||
#endif |
||||
|
||||
#if 0 |
||||
#include <pthread.h> |
||||
|
||||
#include "fttypes.h" |
||||
|
||||
// Used inside the PARTITIONED_COUNTER.
|
||||
struct linked_list_head { |
||||
struct linked_list_element *first; |
||||
}; |
||||
|
||||
|
||||
class PARTITIONED_COUNTER { |
||||
public: |
||||
PARTITIONED_COUNTER(void); |
||||
// Effect: Construct a counter, initialized to zero.
|
||||
|
||||
~PARTITIONED_COUNTER(void); |
||||
// Effect: Destruct the counter.
|
||||
|
||||
void increment(uint64_t amount); |
||||
// Effect: Increment the counter by amount. This is a 64-bit unsigned counter, and if you overflow it, you will get overflowed results (that is mod 2^64).
|
||||
// Requires: Don't use this from a static constructor or destructor.
|
||||
|
||||
uint64_t read(void); |
||||
// Effect: Read the sum.
|
||||
// Requires: Don't use this from a static constructor or destructor.
|
||||
|
||||
private: |
||||
uint64_t _sum_of_dead; // The sum of all thread-local counts from threads that have terminated.
|
||||
pthread_key_t _key; // The pthread_key which gives us the hook to construct and destruct thread-local storage.
|
||||
struct linked_list_head _ll_counter_head; // A linked list of all the thread-local information for this counter.
|
||||
|
||||
// This function is used to destroy the thread-local part of the state when a thread terminates.
|
||||
// But it's not the destructor for the local part of the counter, it's a destructor on a "dummy" key just so that we get a notification when a thread ends.
|
||||
friend void destroy_thread_local_part_of_partitioned_counters (void *); |
||||
}; |
||||
#endif |
||||
@ -0,0 +1,62 @@ |
||||
/* -*- mode: C++; c-basic-offset: 4; indent-tabs-mode: nil -*- */ |
||||
// vim: ft=cpp:expandtab:ts=8:sw=4:softtabstop=4:
|
||||
#ident "$Id$" |
||||
/*======
|
||||
This file is part of PerconaFT. |
||||
|
||||
|
||||
Copyright (c) 2006, 2015, Percona and/or its affiliates. All rights reserved. |
||||
|
||||
PerconaFT is free software: you can redistribute it and/or modify |
||||
it under the terms of the GNU General Public License, version 2, |
||||
as published by the Free Software Foundation. |
||||
|
||||
PerconaFT is distributed in the hope that it will be useful, |
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
GNU General Public License for more details. |
||||
|
||||
You should have received a copy of the GNU General Public License |
||||
along with PerconaFT. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
---------------------------------------- |
||||
|
||||
PerconaFT is free software: you can redistribute it and/or modify |
||||
it under the terms of the GNU Affero General Public License, version 3, |
||||
as published by the Free Software Foundation. |
||||
|
||||
PerconaFT is distributed in the hope that it will be useful, |
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
GNU Affero General Public License for more details. |
||||
|
||||
You should have received a copy of the GNU Affero General Public License |
||||
along with PerconaFT. If not, see <http://www.gnu.org/licenses/>.
|
||||
======= */ |
||||
|
||||
#ident \ |
||||
"Copyright (c) 2006, 2015, Percona and/or its affiliates. All rights reserved." |
||||
|
||||
#pragma once |
||||
|
||||
#include "partitioned_counter.h" |
||||
// PORT2: #include <util/constexpr.h>
|
||||
|
||||
#define TOKUFT_STATUS_INIT(array, k, c, t, l, inc) \ |
||||
do { \
|
||||
array.status[k].keyname = #k; \
|
||||
array.status[k].columnname = #c; \
|
||||
array.status[k].type = t; \
|
||||
array.status[k].legend = l; \
|
||||
constexpr_static_assert( \
|
||||
strcmp(#c, "NULL") && strcmp(#c, "0"), \
|
||||
"Use nullptr for no column name instead of NULL, 0, etc..."); \
|
||||
constexpr_static_assert( \
|
||||
(inc) == TOKU_ENGINE_STATUS || strcmp(#c, "nullptr"), \
|
||||
"Missing column name."); \
|
||||
array.status[k].include = \
|
||||
static_cast<toku_engine_status_include_type>(inc); \
|
||||
if (t == STATUS_PARCOUNT) { \
|
||||
array.status[k].value.parcount = create_partitioned_counter(); \
|
||||
} \
|
||||
} while (0) |
||||
Loading…
Reference in new issue