diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..683b62f --- /dev/null +++ b/.gitignore @@ -0,0 +1,3 @@ +.gradle +.idea +/build \ No newline at end of file diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..70566f2 --- /dev/null +++ b/LICENSE @@ -0,0 +1,674 @@ +GNU GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The GNU General Public License is a free, copyleft license for +software and other kinds of works. + + The licenses for most software and other practical works are designed +to take away your freedom to share and change the works. By contrast, +the GNU General Public License is 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. We, the Free Software Foundation, use the +GNU General Public License for most of our software; it applies also to +any other work released this way by its authors. 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 +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. + + To protect your rights, we need to prevent others from denying you +these rights or asking you to surrender the rights. Therefore, you have +certain responsibilities if you distribute copies of the software, or if +you modify it: responsibilities to respect the freedom of others. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must pass on to the recipients the same +freedoms that you received. 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. + + Developers that use the GNU GPL protect your rights with two steps: +(1) assert copyright on the software, and (2) offer you this License +giving you legal permission to copy, distribute and/or modify it. + + For the developers' and authors' protection, the GPL clearly explains +that there is no warranty for this free software. For both users' and +authors' sake, the GPL requires that modified versions be marked as +changed, so that their problems will not be attributed erroneously to +authors of previous versions. + + Some devices are designed to deny users access to install or run +modified versions of the software inside them, although the manufacturer +can do so. This is fundamentally incompatible with the aim of +protecting users' freedom to change the software. The systematic +pattern of such abuse occurs in the area of products for individuals to +use, which is precisely where it is most unacceptable. Therefore, we +have designed this version of the GPL to prohibit the practice for those +products. If such problems arise substantially in other domains, we +stand ready to extend this provision to those domains in future versions +of the GPL, as needed to protect the freedom of users. + + Finally, every program is threatened constantly by software patents. +States should not allow patents to restrict development and use of +software on general-purpose computers, but in those that do, we wish to +avoid the special danger that patents applied to a free program could +make it effectively proprietary. To prevent this, the GPL assures that +patents cannot be used to render the program non-free. + + 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 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. Use with the GNU Affero General Public License. + + 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 Affero 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 special requirements of the GNU Affero General Public License, +section 13, concerning interaction through a network will apply to the +combination as such. + + 14. Revised Versions of this License. + + The Free Software Foundation may publish revised and/or new versions of +the GNU 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 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 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 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 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 General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . + +Also add information on how to contact you by electronic and paper mail. + + If the program does terminal interaction, make it output a short +notice like this when it starts in an interactive mode: + + {project} Copyright (C) {year} {fullname} + This program 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, your program's commands +might be different; for a GUI interface, you would use an "about box". + + 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 GPL, see +. + + The GNU 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. But first, please read +. \ No newline at end of file diff --git a/README.md b/README.md new file mode 100644 index 0000000..1005a62 --- /dev/null +++ b/README.md @@ -0,0 +1,10 @@ +# Computer and algorithm interaction simulation software (CAISS). +Simulation software contains in core a representation of architecture and algorithm. +Intended for simulation their interactions and listing their results for optimization +purposes. + +### Running in IDEA +Select the `benchmarks.{desired runnable}` and `Run as a console Java application`. + +# License +GNU GENERAL PUBLIC LICENSE Version 3. \ No newline at end of file diff --git a/build.gradle b/build.gradle new file mode 100644 index 0000000..e6cdd18 --- /dev/null +++ b/build.gradle @@ -0,0 +1,58 @@ +/* + * Computer and algorithm interaction simulation software (CAISS). + * Copyright (C) 2016 Sergei Pomelov + * + * 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 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +plugins { + id 'java' + id 'idea' + id 'com.github.johnrengelman.shadow' version '1.2.3' + id 'me.champeau.gradle.jmh' version '0.3.0' + id 'net.ltgt.apt' version '0.6' +} + +repositories { + jcenter() + mavenCentral() +} + +sourceCompatibility = JavaVersion.VERSION_1_8 +//noinspection GroovyUnusedAssignment, while it works don't touch it +targetCompatibility = sourceCompatibility + +tasks.withType(AbstractCompile)*.options*.encoding = "UTF-8" + +jmh.jmhVersion = '1.12' +tasks.jmh.main = 'benchmarks.control.JMHBenchmarksRunner' + +jmhJar { + //noinspection GroovyAssignabilityCheck, while it works don't touch it + manifest.attributes 'Main-Class': tasks.jmh.main + append 'META-INF/BenchmarkList' + append 'META-INF/CompilerHints' +} + +dependencies { + apt "org.openjdk.jmh:jmh-generator-annprocess:${jmh.jmhVersion}" + + compile "org.openjdk.jmh:jmh-core:${jmh.jmhVersion}" + compile "org.slf4j:slf4j-api:1.7.+" + compile "ch.qos.logback:logback-classic:1.1.+" + compile 'com.google.code.findbugs:jsr305:3.0.+' + compile 'com.google.guava:guava:19.0' + + testCompile 'junit:junit:4.12' +} diff --git a/src/main/java/benchmarks/control/AntsRunner.java b/src/main/java/benchmarks/control/AntsRunner.java new file mode 100644 index 0000000..389b053 --- /dev/null +++ b/src/main/java/benchmarks/control/AntsRunner.java @@ -0,0 +1,39 @@ +/* + * Computer and algorithm interaction simulation software (CAISS). + * Copyright (C) 2016 Sergei Pomelov + * + * 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 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +package benchmarks.control; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import benchmarks.tasks.ants.AntsColony; + +/** + * @author Sergey Pomelov on 13/04/2016. + */ +final class AntsRunner { + + private static final Logger log = LoggerFactory.getLogger(AntsRunner.class); + + private AntsRunner() { /* runnable class */ } + + public static void main(String... args) { + GNUCopyright.printLicence(); + log.info(AntsColony.getInstance().getLog()); + } +} diff --git a/src/main/java/benchmarks/control/GNUCopyright.java b/src/main/java/benchmarks/control/GNUCopyright.java new file mode 100644 index 0000000..aa0bdbd --- /dev/null +++ b/src/main/java/benchmarks/control/GNUCopyright.java @@ -0,0 +1,39 @@ +/* + * Computer and algorithm interaction simulation software (CAISS). + * Copyright (C) 2016 Sergei Pomelov + * + * 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 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +package benchmarks.control; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import static util.Constants.GNU_COPYRIGHT_MSG; +import static util.Constants.LS; + +/** + * @author Sergey Pomelov on 15/04/2016. + */ +final class GNUCopyright { + + private static final Logger log = LoggerFactory.getLogger(GNUCopyright.class); + + private GNUCopyright() { /* utility class */ } + + static void printLicence() { + log.info("{}{}", LS, GNU_COPYRIGHT_MSG); + } +} diff --git a/src/main/java/benchmarks/control/JMHBenchmarksRunner.java b/src/main/java/benchmarks/control/JMHBenchmarksRunner.java new file mode 100644 index 0000000..bebb5a6 --- /dev/null +++ b/src/main/java/benchmarks/control/JMHBenchmarksRunner.java @@ -0,0 +1,87 @@ +/* + * Computer and algorithm interaction simulation software (CAISS). + * Copyright (C) 2016 Sergei Pomelov + * + * 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 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +package benchmarks.control; + +import org.openjdk.jmh.annotations.Benchmark; +import org.openjdk.jmh.annotations.BenchmarkMode; +import org.openjdk.jmh.annotations.Fork; +import org.openjdk.jmh.annotations.Measurement; +import org.openjdk.jmh.annotations.OutputTimeUnit; +import org.openjdk.jmh.annotations.Param; +import org.openjdk.jmh.annotations.Scope; +import org.openjdk.jmh.annotations.State; +import org.openjdk.jmh.annotations.Threads; +import org.openjdk.jmh.annotations.Timeout; +import org.openjdk.jmh.annotations.Warmup; +import org.openjdk.jmh.infra.Blackhole; +import org.openjdk.jmh.runner.Runner; +import org.openjdk.jmh.runner.RunnerException; +import org.openjdk.jmh.runner.options.Options; +import org.openjdk.jmh.runner.options.OptionsBuilder; + +import java.util.concurrent.TimeUnit; + +import javax.annotation.ParametersAreNonnullByDefault; + +import benchmarks.tasks.martixes.MatrixTasks; + +import static org.openjdk.jmh.annotations.Mode.AverageTime; +import static org.openjdk.jmh.annotations.Mode.Throughput; + +/** + * @author Sergey Pomelov on 06.04.16. Class can't be final or not public because runtime + * instrumentation reasons. + */ +@Fork(1) +@State(Scope.Benchmark) +@OutputTimeUnit(TimeUnit.MILLISECONDS) +@Warmup(iterations = 5, time = 5) +@Measurement(iterations = 10, time = 5) +@BenchmarkMode(AverageTime) +@Timeout(time = 30, timeUnit = TimeUnit.SECONDS) +@ParametersAreNonnullByDefault +public class JMHBenchmarksRunner { + + @Param({"1", "2", "4", "8"}) + private int threads; + //@Param({"10", "50", "100", "1000", "2000", "5000"}) + private int size; + + public static void main(String... args) throws RunnerException { + GNUCopyright.printLicence(); + final Options options = new OptionsBuilder() + .include(JMHBenchmarksRunner.class.getSimpleName()) + .build(); + new Runner(options).run(); + } + + @Benchmark + public void matrixPow() { + MatrixTasks.matrixPow(threads); + } + + @Warmup(iterations = 3, time = 3) + @Measurement(iterations = 3, time = 3) + @OutputTimeUnit(TimeUnit.SECONDS) + @BenchmarkMode(Throughput) + @Threads(-1) + public void memoryAlloc(Blackhole blackhole) { + blackhole.consume(MatrixTasks.memoryAlloc(size)); + } +} diff --git a/src/main/java/benchmarks/control/ManualBenchmarksRunner.java b/src/main/java/benchmarks/control/ManualBenchmarksRunner.java new file mode 100644 index 0000000..95890ed --- /dev/null +++ b/src/main/java/benchmarks/control/ManualBenchmarksRunner.java @@ -0,0 +1,111 @@ +/* + * Computer and algorithm interaction simulation software (CAISS). + * Copyright (C) 2016 Sergei Pomelov + * + * 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 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +package benchmarks.control; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.io.IOException; +import java.lang.management.ManagementFactory; + +import javax.annotation.ParametersAreNonnullByDefault; + +import benchmarks.control.metrics.Measurer; +import benchmarks.control.metrics.PerformanceRecord; +import benchmarks.tasks.martixes.MatrixTasks; + +import static util.ConversionUtil.bytesToMb; +import static util.TimeUtil.nanoToMls; + +/** + * @author Sergey Pomelov on 06.04.16. + */ +@SuppressWarnings("SameParameterValue") +@ParametersAreNonnullByDefault +final class ManualBenchmarksRunner { + + private static final Logger log = LoggerFactory.getLogger(ManualBenchmarksRunner.class); + + private static final int ITERATIONS = 10; + private static final int MAX_DEGREE = 4; + + private ManualBenchmarksRunner() { /* runnable class */ } + + public static void main(String... args) { + printStats(); + waitForInput(); + log.info("started"); + runBenchmark(); + log.info("press to quit"); + waitForInput(); + System.exit(0); + } + + private static void printStats() { + GNUCopyright.printLicence(); + log.info("Press to start. Cores: {}. Memory: {} Mb.", + Runtime.getRuntime().availableProcessors(), + bytesToMb(Runtime.getRuntime().maxMemory())); + } + + private static void runBenchmark() { + ManagementFactory.getThreadMXBean().setThreadCpuTimeEnabled(true); + for (int i = 0; i <= MAX_DEGREE; i++) { + final int twoPowI = Math.toIntExact(Math.round(StrictMath.pow(2, i))); + measure(() -> MatrixTasks.matrixPow(twoPowI), ITERATIONS, twoPowI + " threads"); + } + } + + private static void measure(Runnable task, int iterations, String label) { + warmUp(task, iterations, label); + rampUp(task, iterations, label); + } + + private static void waitForInput() { + int input = 0; + try { + input = System.in.read(); + } catch (IOException e) { + log.error("{} {}", input, e.getStackTrace()); + } + } + + private static void warmUp(Runnable task, int iterations, String label) { + log.debug("warm up start {}", label); + runSeveralTimes(task, iterations); + log.info("warm up end {}", label); + } + + private static void runSeveralTimes(Runnable task, int iterations) { + for (int i = 0; i < iterations; i++) { + task.run(); + } + } + + private static void rampUp(Runnable task, int iterations, String label) { + log.debug("measuring start {}", label); + final PerformanceRecord info = new Measurer().measurePerformance(() -> + runSeveralTimes(task, iterations), label); + log.info("{}. Time avg: {}ms. Cpu total: {}ms. User total: {}ms.", + label, + (nanoToMls(info.getTime()) / iterations), + (nanoToMls(info.getCpuTime())), + (nanoToMls(info.getUserTime()))); + } +} diff --git a/src/main/java/benchmarks/control/SimulationControllerRunner.java b/src/main/java/benchmarks/control/SimulationControllerRunner.java new file mode 100644 index 0000000..f0e8776 --- /dev/null +++ b/src/main/java/benchmarks/control/SimulationControllerRunner.java @@ -0,0 +1,39 @@ +/* + * Computer and algorithm interaction simulation software (CAISS). + * Copyright (C) 2016 Sergei Pomelov + * + * 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 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +package benchmarks.control; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import simulation.control.SimulationController; + +/** + * @author Sergey Pomelov on 15/04/2016. + */ +public final class SimulationControllerRunner { + + private static final Logger log = LoggerFactory.getLogger(SimulationControllerRunner.class); + + private SimulationControllerRunner() { /* runnable class */ } + + public static void main(String... args) { + GNUCopyright.printLicence(); + log.info((new SimulationController()).simulate()); + } +} diff --git a/src/main/java/benchmarks/control/metrics/Measurer.java b/src/main/java/benchmarks/control/metrics/Measurer.java new file mode 100644 index 0000000..a1bd634 --- /dev/null +++ b/src/main/java/benchmarks/control/metrics/Measurer.java @@ -0,0 +1,68 @@ +/* + * Computer and algorithm interaction simulation software (CAISS). + * Copyright (C) 2016 Sergei Pomelov + * + * 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 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +package benchmarks.control.metrics; + +import java.lang.management.ManagementFactory; +import java.util.List; +import java.util.Map; +import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.CopyOnWriteArrayList; + +import javax.annotation.Nonnull; +import javax.annotation.ParametersAreNonnullByDefault; +import javax.annotation.concurrent.ThreadSafe; + +/** + * @author Sergey Pomelov on 06.04.16. + */ +@SuppressWarnings("ReturnOfCollectionOrArrayField") +@ThreadSafe +@ParametersAreNonnullByDefault +public final class Measurer { + + @Nonnull + private final Map> measures = new ConcurrentHashMap<>(4, 0.75f); + + public PerformanceRecord measurePerformance(Runnable task, String label) { + final long startNanoTime = System.nanoTime(); + final long startCpuTime = getCpuTimeNano(); + final long startUserTime = getUserTimeNano(); + task.run(); + final PerformanceRecord performanceRecord = + new PerformanceRecord(label, + System.nanoTime() - startNanoTime, + getCpuTimeNano() - startCpuTime, + getUserTimeNano() - startUserTime); + measures.getOrDefault(label, new CopyOnWriteArrayList<>()).add(performanceRecord); + return performanceRecord; + } + + @Nonnull + public Map> getMeasures() { + return measures; + } + + private static long getCpuTimeNano() { + return ManagementFactory.getThreadMXBean().getCurrentThreadCpuTime(); + } + + private static long getUserTimeNano() { + return ManagementFactory.getThreadMXBean().getCurrentThreadUserTime(); + } +} diff --git a/src/main/java/benchmarks/control/metrics/PerformanceRecord.java b/src/main/java/benchmarks/control/metrics/PerformanceRecord.java new file mode 100644 index 0000000..00be546 --- /dev/null +++ b/src/main/java/benchmarks/control/metrics/PerformanceRecord.java @@ -0,0 +1,61 @@ +/* + * Computer and algorithm interaction simulation software (CAISS). + * Copyright (C) 2016 Sergei Pomelov + * + * 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 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +package benchmarks.control.metrics; + +import javax.annotation.Nonnull; +import javax.annotation.ParametersAreNonnullByDefault; +import javax.annotation.concurrent.Immutable; + +/** + * @author Sergey Pomelov on 06.04.16. + */ +@Immutable +@ParametersAreNonnullByDefault +public final class PerformanceRecord { + + @Nonnull + private final String label; + private final long time; + private final long cpuTime; + private final long userTime; + + public PerformanceRecord(String label, long time, long cpuTime, long userTime) { + this.label = label; + this.time = time; + this.cpuTime = cpuTime; + this.userTime = userTime; + } + + @Nonnull + public String getLabel() { + return label; + } + + public long getTime() { + return time; + } + + public long getCpuTime() { + return cpuTime; + } + + public long getUserTime() { + return userTime; + } +} diff --git a/src/main/java/benchmarks/tasks/ants/AntRunResult.java b/src/main/java/benchmarks/tasks/ants/AntRunResult.java new file mode 100644 index 0000000..69c1d35 --- /dev/null +++ b/src/main/java/benchmarks/tasks/ants/AntRunResult.java @@ -0,0 +1,61 @@ +/* + * Computer and algorithm interaction simulation software (CAISS). + * Copyright (C) 2016 Sergei Pomelov + * + * 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 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +package benchmarks.tasks.ants; + +import javax.annotation.Nonnull; +import javax.annotation.ParametersAreNonnullByDefault; +import javax.annotation.concurrent.Immutable; + +@Immutable +@ParametersAreNonnullByDefault +public final class AntRunResult { + @Nonnull + private final int[] tour; + private final long len; + @Nonnull + private final double[][] delta; + @Nonnull + private final String journal; + + AntRunResult(int[] inTour, long inLen, double[][] inDelta, String inLog) { + tour = inTour.clone(); + len = inLen; + delta = inDelta.clone(); + journal = inLog; + } + + @Nonnull + public int[] getTour() { + return tour.clone(); + } + + public long getLen() { + return len; + } + + @Nonnull + public double[][] getDelta() { + return delta.clone(); + } + + @Nonnull + public String getJournal() { + return journal; + } +} diff --git a/src/main/java/benchmarks/tasks/ants/AntsColony.java b/src/main/java/benchmarks/tasks/ants/AntsColony.java new file mode 100644 index 0000000..17f2b4c --- /dev/null +++ b/src/main/java/benchmarks/tasks/ants/AntsColony.java @@ -0,0 +1,173 @@ +/* + * Computer and algorithm interaction simulation software (CAISS). + * Copyright (C) 2016 Sergei Pomelov + * + * 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 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +package benchmarks.tasks.ants; + +import com.google.common.util.concurrent.AtomicDouble; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.util.Collection; +import java.util.concurrent.CopyOnWriteArrayList; +import java.util.concurrent.SynchronousQueue; +import java.util.concurrent.ThreadPoolExecutor; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.atomic.AtomicBoolean; +import java.util.concurrent.atomic.AtomicInteger; + +import javax.annotation.Nonnull; +import javax.annotation.concurrent.Immutable; + +import static util.Constants.LS; + +@Immutable +public final class AntsColony implements IAntsOptimization { + + private static final long serialVersionUID = 1858529504894436119L; + private static final Logger log = LoggerFactory.getLogger(AntsColony.class); + private static final IGraph GRAPH = new GraphMatrix(); + private static final int SIZE = GRAPH.getSize(); + private static final double EVAPORATION_COEFFICIENT = 0.1; + private static final int ANTS_COUNT = 32; + private static final double VAL = 1; + + private final StringBuilder out = new StringBuilder(512); + private final double[][] trail = new double[SIZE][SIZE]; + private final Collection bestRunVertexes = new CopyOnWriteArrayList<>(); + + private final AtomicBoolean mutex = new AtomicBoolean(); + private final AtomicInteger antsGoodRuns = new AtomicInteger(0); + private final AtomicInteger bestRunLength = new AtomicInteger(Integer.MAX_VALUE); + private final AtomicDouble avg = new AtomicDouble(VAL); + + private AntsColony() { + for (int i = 0; i < SIZE; i++) { + for (int j = 0; j < SIZE; j++) { + trail[i][j] = VAL; + } + } + + runAnts(); + + log.info("Ant optimization finished!"); + final long start = System.currentTimeMillis(); + out.append("Best: |").append(bestRunLength).append('|') + .append(printArray(bestRunVertexes)).append(" Total: ") + .append(System.currentTimeMillis() - start).append(" ms"); + } + + @Nonnull + public static IAntsOptimization getInstance() { + return SingletonHolder.INSTANCE; + } + + @Override + @Nonnull + public String getLog() { + return out.toString(); + } + + @Nonnull + private static String printArray(final Iterable list) { + final StringBuilder out = new StringBuilder(64); + for (final int anArray : list) { + out.append(anArray + 1).append('>'); + } + return out.toString(); + } + + private void runAnts() { + final ThreadPoolExecutor executor = + new ThreadPoolExecutor(1, 100, 1, TimeUnit.SECONDS, + new SynchronousQueue<>(), runnable -> { + final Thread thread = new Thread(runnable, "ant"); + thread.setDaemon(true); + thread.setPriority(Thread.NORM_PRIORITY); + return thread; + }); + + final Runnable antRun = () -> { + final AntRunResult runResult = new RunningAnt(GRAPH, trail.clone(), avg.get()) + .getRunResult(); + out.append(runResult.getJournal()).append(LS); + log.info("ant run {} {}", runResult.getJournal(), bestRunLength); + + if (runResult.getLen() < bestRunLength.intValue()) { + final int[] currentRunTour = runResult.getTour(); + bestRunLength.set((int) runResult.getLen()); + bestRunVertexes.clear(); + for (final int vertex : currentRunTour) { + bestRunVertexes.add(vertex); + } + + final double avgDivider = 0.5 * StrictMath.pow(runResult.getTour().length, 2); + avg.set(avg.get() / avgDivider); + log.info("ant find better: {} {}", + antsGoodRuns.incrementAndGet(), + runResult.getJournal()); + } + applyPheromones(runResult); + }; + + out.append(LS).append("====================AntsRun=========================").append(LS); + for (int antsRuns = 0; antsRuns < ANTS_COUNT; antsRuns++) { + executor.submit(antRun); + } + + //noinspection MethodCallInLoopCondition, by design + while (executor.getTaskCount() != executor.getCompletedTaskCount()) { + try { + Thread.sleep(100); + } catch (InterruptedException ignore) { + } + } + executor.shutdown(); + } + + private void applyPheromones(final AntRunResult runResult) { + final double min = avg.get() / runResult.getTour().length; + double max = 0; + final double stick = 1 - EVAPORATION_COEFFICIENT; + avg.set(0); + + final int trailLength = trail.length; + for (int i = 0; i < trailLength; i++) { + for (int j = 0; j < i; j++) { + double t = (stick * trail[i][j]) + (EVAPORATION_COEFFICIENT * + (runResult.getDelta()[i][j] + runResult.getDelta()[j][i])); + if (t < min) { + t = min; + } + trail[i][j] = t; + trail[j][i] = t; + if (t > max) { + max = t; + } + synchronized (mutex) { + avg.set(avg.get() + t); + } + } + } + } + + private static final class SingletonHolder { + @Nonnull + private static final IAntsOptimization INSTANCE = new AntsColony(); + } +} diff --git a/src/main/java/benchmarks/tasks/ants/GraphMatrix.java b/src/main/java/benchmarks/tasks/ants/GraphMatrix.java new file mode 100644 index 0000000..de54a07 --- /dev/null +++ b/src/main/java/benchmarks/tasks/ants/GraphMatrix.java @@ -0,0 +1,116 @@ +/* + * Computer and algorithm interaction simulation software (CAISS). + * Copyright (C) 2016 Sergei Pomelov + * + * 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 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +package benchmarks.tasks.ants; + +import java.security.SecureRandom; +import java.util.ArrayList; +import java.util.List; +import java.util.Random; + +import javax.annotation.Nonnegative; +import javax.annotation.Nonnull; +import javax.annotation.concurrent.Immutable; + +/** + * @author Sergei Pomelov 04.01.2015. + */ +@Immutable +public final class GraphMatrix implements IGraph { + + private static final long serialVersionUID = 4778301831516758978L; + private static final Random rand = new SecureRandom(); + @Nonnegative + private static final int SIZE = 256; + @Nonnegative + private static final int MAX_LENGTH = 10; // maximum value in cells. + + @Nonnull + private final List> matrix = new ArrayList<>(SIZE); + + GraphMatrix() { + generateLowerHalfRandom(); + symmetry(); + zeroDiagonal(); + check(); + } + + @Override + @Nonnegative + public int getDist(int start, int destiny) { + if ((start >= SIZE) || (destiny >= SIZE)) { + throw new IllegalArgumentException("GraphMatrix size overflowed! " + + start + ' ' + destiny); + } else if (start == destiny) { + return Integer.MAX_VALUE; + } else { + final Integer out = matrix.get(start).get(destiny); + return (out <= 0) ? Integer.MAX_VALUE : out; + } + } + + @Override + @Nonnegative + public int getSize() { + return SIZE; + } + + private void generateLowerHalfRandom() { + for (int i = 0; i < SIZE; i++) { + //noinspection ObjectAllocationInLoop, this is by design + final List list = new ArrayList<>(SIZE); + for (int j = 0; j <= i; j++) { + // noinspection no loss here while MAX_LENGTH < + // Integer.Max + list.add(rand.nextInt(MAX_LENGTH)); + } + matrix.add(list); + } + } + + private void symmetry() { + for (int i = 0; i < SIZE; i++) { + for (int j = 0; j < SIZE; j++) { + if (j > i) { + matrix.get(i).add(j, matrix.get(j).get(i)); + } + } + } + } + + private void zeroDiagonal() { + for (int i = 0; i < SIZE; i++) { + matrix.get(i).set(i, 0); + } + } + + private void check() { + for (int i = 0; i < SIZE; i++) { + final List list = matrix.get(i); + final int subSize = list.size(); + if (subSize != SIZE) { + throw new IllegalStateException("Non square matrix! " + i); + } + for (int j = 0; j < i; j++) { + if (getDist(i, j) != getDist(j, i)) { + throw new IllegalStateException("Non symmetric matrix! " + i + ' ' + j); + } + } + } + } +} diff --git a/src/main/java/benchmarks/tasks/ants/IAntsOptimization.java b/src/main/java/benchmarks/tasks/ants/IAntsOptimization.java new file mode 100644 index 0000000..6806556 --- /dev/null +++ b/src/main/java/benchmarks/tasks/ants/IAntsOptimization.java @@ -0,0 +1,32 @@ +/* + * Computer and algorithm interaction simulation software (CAISS). + * Copyright (C) 2016 Sergei Pomelov + * + * 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 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +package benchmarks.tasks.ants; + +import java.io.Serializable; + +import javax.annotation.Nonnull; + +/** + * @author Sergei Pomelov 20.01.15. + */ +@FunctionalInterface +public interface IAntsOptimization extends Serializable { + @Nonnull + String getLog(); +} diff --git a/src/main/java/benchmarks/tasks/ants/IGraph.java b/src/main/java/benchmarks/tasks/ants/IGraph.java new file mode 100644 index 0000000..7b86557 --- /dev/null +++ b/src/main/java/benchmarks/tasks/ants/IGraph.java @@ -0,0 +1,34 @@ +/* + * Computer and algorithm interaction simulation software (CAISS). + * Copyright (C) 2016 Sergei Pomelov + * + * 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 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +package benchmarks.tasks.ants; + +import java.io.Serializable; + +import javax.annotation.Nonnegative; + +/** + * @author Sergei Pomelov 07.01.2015. + */ +interface IGraph extends Serializable { + @Nonnegative + int getDist(int start, int destiny); + + @Nonnegative + int getSize(); +} diff --git a/src/main/java/benchmarks/tasks/ants/RunningAnt.java b/src/main/java/benchmarks/tasks/ants/RunningAnt.java new file mode 100644 index 0000000..a28c946 --- /dev/null +++ b/src/main/java/benchmarks/tasks/ants/RunningAnt.java @@ -0,0 +1,169 @@ +/* + * Computer and algorithm interaction simulation software (CAISS). + * Copyright (C) 2016 Sergei Pomelov + * + * 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 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +package benchmarks.tasks.ants; + +import java.security.SecureRandom; +import java.util.Random; + +import javax.annotation.Nonnegative; +import javax.annotation.Nonnull; +import javax.annotation.Nullable; +import javax.annotation.ParametersAreNonnullByDefault; +import javax.annotation.concurrent.Immutable; + +@SuppressWarnings("SameParameterValue") +@Immutable +@ParametersAreNonnullByDefault +final class RunningAnt { + private static final Random rand = new SecureRandom(); + private static final double COMP_MAX_ERR = 0.000000001; + + @Nonnull + private final IGraph graphMatrix; + @Nonnull + private final int[] tour; + @Nonnull + private final int[] allowedVertexes; + + @Nonnull + private final boolean[] visited; + @Nonnull + private final double[][] trailDelta; + @Nonnull + private final double[][] vertexQualities; + + @Nonnegative + private final int size; + @Nonnull + private final AntRunResult runResult; + private final double avgLen; + private final long start = System.currentTimeMillis(); + + RunningAnt(IGraph inSquareSymmetricGraph, double[][] inTrail, double inAvgLen) { + graphMatrix = inSquareSymmetricGraph; + size = graphMatrix.getSize(); + avgLen = inAvgLen; + + tour = new int[size]; + allowedVertexes = new int[size]; + visited = new boolean[size]; + trailDelta = new double[size][size]; + vertexQualities = new double[size][size]; + + for (int i = 0; i < size; i++) { + visited[i] = false; + for (int j = 0; j < size; j++) { + trailDelta[i][j] = 0; + vertexQualities[i][j] = StrictMath.pow(graphMatrix.getDist(i, j), -1.0) + * inTrail[i][j]; + } + } + + runResult = runAnt(); + } + + @Nonnull + public AntRunResult getRunResult() { + return runResult; + } + + @Nonnull + private static String printArray(final int... array) { + final StringBuilder out = new StringBuilder(64); + for (final int anArray : array) { + out.append(anArray + 1).append('>'); + } + return out.toString(); + } + + @Nonnull + private AntRunResult runAnt() { + int src; + long len = 0; + + src = rand.nextInt(tour.length); + tour[0] = src; + visited[src] = true; + + boolean success = true; + for (int i = 1; (i < size) && success; i++) { + final Integer dstIndex = find(src); + if (dstIndex == null) { + len = Integer.MAX_VALUE; + success = false; + } else { + final int dst = allowedVertexes[dstIndex]; + visited[dst] = true; + len += graphMatrix.getDist(src, dst); + tour[i] = dst; + src = dst; + } + } + + if (success) { + final double chg = avgLen / len; + sprayTrail(chg); + } + + return new AntRunResult(tour, len, trailDelta, + '|' + ((len < Long.MAX_VALUE) ? String.valueOf(len) : "failure") + '|' + + printArray(tour) + ' ' + (System.currentTimeMillis() - start) + " ms"); + } + + private void sprayTrail(final double amount) { + int src = tour[0]; + for (final int vertex : tour) { // iterates through the tour + final int dst = src; + src = vertex; + trailDelta[src][dst] += amount; + } + } + + @Nullable + @Nonnegative + private Integer find(final int inScr) { + int n = 0; // possible to go vertexes counter + double totalWeight = 0; + final double[] weights = new double[size]; + for (int j = 0; j < size; j++) { + boolean success = true; + final double vertexQuality = vertexQualities[inScr][j]; + if (visited[j] || (vertexQuality < COMP_MAX_ERR)) { + success = false; + } + if (success) { + totalWeight += vertexQuality; + weights[n] = totalWeight; + allowedVertexes[n] = j; + n++; + } + } + + int result = 0; + final double val = totalWeight * rand.nextDouble(); + for (int i = 0; i < n; i++) { + if (weights[i] > val) { + return i; + } else { + result = n; + } + } + return (totalWeight == 0) ? null : result; + } +} diff --git a/src/main/java/benchmarks/tasks/ants/package-info.java b/src/main/java/benchmarks/tasks/ants/package-info.java new file mode 100644 index 0000000..751f30b --- /dev/null +++ b/src/main/java/benchmarks/tasks/ants/package-info.java @@ -0,0 +1,22 @@ +/* + * Computer and algorithm interaction simulation software (CAISS). + * Copyright (C) 2016 Sergei Pomelov + * + * 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 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +/** + * @author Sergei Pomelov on 18.03.15. Computational experiment with ants. + */ +package benchmarks.tasks.ants; \ No newline at end of file diff --git a/src/main/java/benchmarks/tasks/martixes/DataProcessor.java b/src/main/java/benchmarks/tasks/martixes/DataProcessor.java new file mode 100644 index 0000000..7cc63a6 --- /dev/null +++ b/src/main/java/benchmarks/tasks/martixes/DataProcessor.java @@ -0,0 +1,55 @@ +/* + * Computer and algorithm interaction simulation software (CAISS). + * Copyright (C) 2016 Sergei Pomelov + * + * 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 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +package benchmarks.tasks.martixes; + +import java.security.SecureRandom; +import java.util.Random; + +/** + * @author Sergey Pomelov on 06.04.16. + */ +final class DataProcessor { + + private DataProcessor() { /* utility class */ } + + static void processArray(byte[][] data, int taskMultiplicator) { + final int cols = data.length; + final int rows = data[0].length; + for (int loop = 0; loop < taskMultiplicator; loop++) { + for (int i = 0; i < cols; i++) { + for (int j = 0; j < rows; j++) { + data[i][j] *= 2; + } + } + } + } + + static byte[][] generateRandomArray(int rows, int cols) { + final byte[][] out = new byte[rows][cols]; + final Random random = new SecureRandom(); + + for (int i = 0; i < rows; i++) { + //noinspection ObjectAllocationInLoop, by design + final byte[] row = new byte[cols]; + random.nextBytes(row); + out[i] = row; + } + return out; + } +} diff --git a/src/main/java/benchmarks/tasks/martixes/MatrixTasks.java b/src/main/java/benchmarks/tasks/martixes/MatrixTasks.java new file mode 100644 index 0000000..f2b6124 --- /dev/null +++ b/src/main/java/benchmarks/tasks/martixes/MatrixTasks.java @@ -0,0 +1,42 @@ +/* + * Computer and algorithm interaction simulation software (CAISS). + * Copyright (C) 2016 Sergei Pomelov + * + * 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 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +package benchmarks.tasks.martixes; + +import javax.annotation.Nonnegative; + +/** + * @author Sergey Pomelov on 06.04.16. + */ +public final class MatrixTasks { + + private static final int ITERATIONS = 1; + private static final int SQUARE_ROOT_OF_DATA_SIZE = 128; + private static final int CALCULATIONS_MULTIPLICATOR = 100000; + + private MatrixTasks() { /* utility class*/ } + + public static void matrixPow(@Nonnegative int threads) { + TasksRunner.runExperiment(threads, + ITERATIONS, SQUARE_ROOT_OF_DATA_SIZE, CALCULATIONS_MULTIPLICATOR); + } + + public static byte[][] memoryAlloc(int size) { + return new byte[size][size]; + } +} diff --git a/src/main/java/benchmarks/tasks/martixes/Reporter.java b/src/main/java/benchmarks/tasks/martixes/Reporter.java new file mode 100644 index 0000000..77b7b5c --- /dev/null +++ b/src/main/java/benchmarks/tasks/martixes/Reporter.java @@ -0,0 +1,44 @@ +/* + * Computer and algorithm interaction simulation software (CAISS). + * Copyright (C) 2016 Sergei Pomelov + * + * 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 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +package benchmarks.tasks.martixes; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import benchmarks.control.metrics.PerformanceRecord; + +import static util.TimeUtil.nanoToMls; + +/** + * @author Sergey Pomelov on 06.04.16. + */ +final class Reporter { + + private static final Logger log = LoggerFactory.getLogger(Reporter.class); + + private Reporter() { /* utility class*/ } + + public static void report(PerformanceRecord info) { + log.info("{}. Time : {}ms. Cpu total: {}ms. User total: {}ms.", + info.getLabel(), + nanoToMls(info.getTime()), + nanoToMls(info.getCpuTime()), + nanoToMls(info.getUserTime())); + } +} diff --git a/src/main/java/benchmarks/tasks/martixes/TasksRunner.java b/src/main/java/benchmarks/tasks/martixes/TasksRunner.java new file mode 100644 index 0000000..46c90d1 --- /dev/null +++ b/src/main/java/benchmarks/tasks/martixes/TasksRunner.java @@ -0,0 +1,74 @@ +/* + * Computer and algorithm interaction simulation software (CAISS). + * Copyright (C) 2016 Sergei Pomelov + * + * 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 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +package benchmarks.tasks.martixes; + +import java.util.concurrent.ArrayBlockingQueue; +import java.util.concurrent.ThreadPoolExecutor; +import java.util.concurrent.TimeUnit; + +import benchmarks.control.metrics.Measurer; + +/** + * @author Sergey Pomelov on 06.04.16. + */ +@SuppressWarnings("SameParameterValue") +final class TasksRunner { + + private TasksRunner() { /* utility class */ } + + static void runExperiment(int threads, int runs, int problemSize, int taskMultiplicator) { + final Runnable divider = generateTask( + DataProcessor.generateRandomArray(problemSize, problemSize / threads), + taskMultiplicator); + Reporter.report(new Measurer().measurePerformance(() -> { + for (int i = 0; i < runs; i++) { + final ThreadPoolExecutor executor = generateExecutor(threads); + for (int threadIdx = 1; threadIdx <= threads; threadIdx++) { + executor.submit(divider); + } + awaitShutdown(executor); + } + }, "task")); + } + + private static Runnable generateTask(byte[][] data, int taskMultiplicator) { + return () -> Reporter.report(new Measurer().measurePerformance(() -> + DataProcessor.processArray(data, taskMultiplicator), "parallel task")); + } + + private static ThreadPoolExecutor generateExecutor(int size) { + return new ThreadPoolExecutor(size, size, 1, + TimeUnit.NANOSECONDS, new ArrayBlockingQueue<>(1), new ThreadFactoryImpl()); + } + + @SuppressWarnings("MethodCallInLoopCondition") + private static void await(ThreadPoolExecutor executor) { + while (executor.getTaskCount() != executor.getCompletedTaskCount()) { + try { + Thread.sleep(1); + } catch (InterruptedException ignore) { + } + } + } + + private static void awaitShutdown(ThreadPoolExecutor executor) { + await(executor); + executor.shutdownNow(); + } +} diff --git a/src/main/java/benchmarks/tasks/martixes/ThreadFactoryImpl.java b/src/main/java/benchmarks/tasks/martixes/ThreadFactoryImpl.java new file mode 100644 index 0000000..4cfbccd --- /dev/null +++ b/src/main/java/benchmarks/tasks/martixes/ThreadFactoryImpl.java @@ -0,0 +1,52 @@ +/* + * Computer and algorithm interaction simulation software (CAISS). + * Copyright (C) 2016 Sergei Pomelov + * + * 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 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +package benchmarks.tasks.martixes; + +import java.util.concurrent.ThreadFactory; +import java.util.concurrent.atomic.AtomicInteger; + +import javax.annotation.ParametersAreNonnullByDefault; + +/** + * @author Sergey Pomelov on 06.04.16. + */ +@ParametersAreNonnullByDefault +final class ThreadFactoryImpl implements ThreadFactory { + + private static final AtomicInteger poolNumber = new AtomicInteger(1); + private final ThreadGroup group; + private final AtomicInteger threadNumber = new AtomicInteger(1); + private final String namePrefix; + + ThreadFactoryImpl() { + final SecurityManager securityManager = System.getSecurityManager(); + group = (securityManager != null) ? + securityManager.getThreadGroup() : Thread.currentThread().getThreadGroup(); + namePrefix = "pool-" + poolNumber.getAndIncrement() + "-thread-"; + } + + @Override + public Thread newThread(Runnable run) { + Thread thread = new Thread(group, run, namePrefix + threadNumber.getAndIncrement(), 0); + if (thread.isDaemon()) { + thread.setDaemon(false); + } + return thread; + } +} \ No newline at end of file diff --git a/src/main/java/simulation/control/ISimulationController.java b/src/main/java/simulation/control/ISimulationController.java new file mode 100644 index 0000000..0c988ce --- /dev/null +++ b/src/main/java/simulation/control/ISimulationController.java @@ -0,0 +1,32 @@ +/* + * Computer and algorithm interaction simulation software (CAISS). + * Copyright (C) 2016 Sergei Pomelov + * + * 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 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +package simulation.control; + +import java.io.Serializable; + +import javax.annotation.Nonnull; + +/** + * @author Sergei Pomelov at 2.6.14. Main computational process controller + */ +@FunctionalInterface +interface ISimulationController extends Serializable { + @Nonnull + String simulate(); +} diff --git a/src/main/java/simulation/control/SimulationController.java b/src/main/java/simulation/control/SimulationController.java new file mode 100644 index 0000000..b38758d --- /dev/null +++ b/src/main/java/simulation/control/SimulationController.java @@ -0,0 +1,133 @@ +/* + * Computer and algorithm interaction simulation software (CAISS). + * Copyright (C) 2016 Sergei Pomelov + * + * 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 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +package simulation.control; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.util.Optional; + +import javax.annotation.Nonnull; +import javax.annotation.ParametersAreNonnullByDefault; +import javax.annotation.concurrent.Immutable; + +import simulation.structures.algorithm.Algorithm; +import simulation.structures.algorithm.AlgorithmBuilder; +import simulation.structures.architecture.ArchitectureBuilder; +import simulation.structures.architecture.ArithmeticNode; +import simulation.structures.architecture.Computer; +import simulation.structures.architecture.DataLink; +import simulation.structures.commons.StructureElement; +import simulation.structures.interaction.DataBlock; +import simulation.structures.interaction.DataType; +import simulation.structures.interaction.OperationType; +import simulation.structures.interaction.OperationWithData; + +import static util.Constants.LS; + +/** + * @author Sergei Pomelov on 22.2.14. Class for control simulation process. Contains it logics. + * @see TasksPlanner + */ +@Immutable +@ParametersAreNonnullByDefault +public final class SimulationController implements ISimulationController { + + private static final Logger log = LoggerFactory.getLogger(SimulationController.class); + + private static final long serialVersionUID = 2150290747465006705L; + + private final DataBlock subMatrix = new DataBlock("subArray", DataType.FOUR_B_FL, 500L * 500L); + private final OperationWithData subInverse = + new OperationWithData("inverse", OperationType.INVERSE, subMatrix); + private final OperationWithData transferSmall = + new OperationWithData("inverse", OperationType.TRANSFER, subMatrix); + + public SimulationController() { + } + + @Nonnull + @Override + public String simulate() { + final StringBuilder out = new StringBuilder(""); + + final Algorithm alg = AlgorithmBuilder.createAlgorithm(); + + final Computer comp1 = ArchitectureBuilder.buildOneCore(); + final Computer comp2 = ArchitectureBuilder.buildTwoCore(); + final Computer comp3 = ArchitectureBuilder.buildFourCore(); + + final TasksPlanner timeManager1 = new TasksPlanner(comp1); + final TasksPlanner timeManager2 = new TasksPlanner(comp2); + final TasksPlanner timeManager3 = new TasksPlanner(comp3); + + addElementsListInfo(alg.getStructure(), out, "ALGORITHM:"); + addElementsListInfo(comp1.getArchitecture(), out, "ARCHITECTURE:"); + + doAndLogFourOperations(timeManager1, comp1, out, "TIMING 1Core:"); + doAndLogFourOperations(timeManager2, comp2, out, "TIMING 2Core:"); + doAndLogFourOperations(timeManager3, comp3, out, "TIMING 4Core:"); + + return out.toString(); + } + + private static void addElementsListInfo(Iterable elements, + StringBuilder out, String label) { + addDivider(out, label); + for (StructureElement element : elements) { + out.append(element.info()); + } + } + + private static void addDivider(StringBuilder out, String label) { + out.append(LS).append(LS).append("===================================================") + .append(LS).append(label).append(LS); + } + + private void doAndLogFourOperations(TasksPlanner timeManager, Computer comp, StringBuilder out, + String label) { + addDivider(out, label); + doFourOperations(timeManager, comp, out); + } + + private void doFourOperations(TasksPlanner timeManager, Computer comp, StringBuilder out) { + for (int i = 1; i <= 4; i++) { + doOperation(timeManager, comp); + } + out.append(timeManager.getLog()).append(timeManager.printTimings()); + } + + private boolean doOperation(TasksPlanner timeManager, Computer comp) { + DataLink busDataLink = null; + for (final DataLink dataLink : comp.getArchitecture()) { + busDataLink = dataLink; + } + + final Optional core = timeManager.getFreeArNode(comp.getArchNodes()); + if (core.isPresent()) { + timeManager.transfer(comp.getMemoryNodes().get(0), + busDataLink, core.get(), transferSmall); + timeManager.calculate(core.get(), subInverse); + return true; + } else { + log.error("Can't find a free node in {}.", comp); + return false; + } + } +} diff --git a/src/main/java/simulation/control/TasksPlanner.java b/src/main/java/simulation/control/TasksPlanner.java new file mode 100644 index 0000000..f4e7c43 --- /dev/null +++ b/src/main/java/simulation/control/TasksPlanner.java @@ -0,0 +1,258 @@ +/* + * Computer and algorithm interaction simulation software (CAISS). + * Copyright (C) 2016 Sergei Pomelov + * + * 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 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +package simulation.control; + +import com.google.common.collect.ImmutableList; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.HashMap; +import java.util.Iterator; +import java.util.Map.Entry; +import java.util.Optional; + +import javax.annotation.Nonnegative; +import javax.annotation.Nonnull; +import javax.annotation.Nullable; + +import simulation.structures.architecture.ArchitectureComponent; +import simulation.structures.architecture.ArithmeticNode; +import simulation.structures.architecture.Computer; +import simulation.structures.architecture.DataLink; +import simulation.structures.architecture.MemoryNode; +import simulation.structures.interaction.OperationWithData; + +import static util.Constants.LS; +import static util.Restrictions.containsNull; + +/** + * @author Sergei Pomelov on 9.3.14. Utility class wich plans computational process by finding + * operarion executors. Second puropose is writing a computationsl process journal. + */ +final class TasksPlanner { + private static final Logger log = LoggerFactory.getLogger(TasksPlanner.class); + /** temporary list of current computer arithmetic nodes */ + @Nonnull + private final Collection cores = new ArrayList<>(8); + /** temporary list of current computer memory nodes */ + @Nonnull + private final Collection memory = new ArrayList<>(4); + /** + * temporary table with information about computational tasks linked with components finish + * time + */ + @Nonnull + private HashMap timeTable = new HashMap<>(8); + /** computational process journal */ + @Nonnull + private StringBuilder journal = new StringBuilder(""); + + TasksPlanner(final Computer computer) { + load(computer); + } + + /** + * @param computer for init class: could be automated. Currently if you want correct results you + * should do it manually before any other tasks for this class. + */ + void load(Computer computer) { + if (computer == null) { + throw new IllegalArgumentException("The computer param shouldn't be null!"); + } + timeTable = new HashMap<>(16); + cores.clear(); + memory.clear(); + cores.addAll(computer.getArchNodes()); + memory.addAll(computer.getMemoryNodes()); + journal = new StringBuilder(""); + } + + /** + * @return computational process journal in text format. + */ + @Nonnull + String getLog() { + return journal.toString(); + } + + @Nullable + Collection getArchNodes() { + return ImmutableList.copyOf(cores); + } + + @Nullable + Collection getMemoryNodes() { + return ImmutableList.copyOf(memory); + } + + private boolean addTask(ArchitectureComponent actor, Long startTime, Long time) { + if (containsNull(actor, startTime, time)) { + return false; + } + final Long newTime = ((startTime < getTime(actor)) ? getTime(actor) : startTime) + time; + timeTable.put(actor, newTime); + return true; + } + + /** + * @param operationWithData operation should be done + * @return assign node for operationWithData and return it. + */ + @Nullable + private ArrayList getSuccessArNode(OperationWithData operationWithData) { + final ArrayList readyCores = new ArrayList<>(8); + cores.stream().forEach(core -> core.getAllowedOperations().stream() + .filter(oper -> oper.getOperation().equals(operationWithData)) + .forEach(oper -> readyCores.add(core))); + return readyCores; + } + + /** + * @return print current time table state. + */ + @Nonnull + String printTimings() { + final StringBuilder timings = new StringBuilder(64); + timings.append(LS); + final Iterator componentIterator = timeTable.keySet().iterator(); + componentIterator.forEachRemaining(actor -> timings.append(actor.getName()).append(" - ") + .append(timeTable.get(actor)).append("ms").append(LS)); + return "Timings: " + timings + LS + "Total time: " + getMaxTime() + " ms" + LS; + } + + /** @return current predicted finishing time. */ + @Nonnull + @Nonnegative + private Long getMaxTime() { + Long maxTime = 0L; + final Iterator> componentIterator = + timeTable.entrySet().iterator(); + //noinspection MethodCallInLoopCondition, by design + for (Entry actor = componentIterator.next(); + componentIterator.hasNext() && (actor != null); actor = componentIterator.next()) { + Long endTime = timeTable.get(actor.getKey()); + if (maxTime < endTime) { + maxTime = endTime; + } + } + return maxTime; + } + + /** + * @param nodes nodes through which we should search + * @return find first finishing node for planning. + */ + @Nonnull + Optional getFreeArNode(Iterable nodes) { + ArithmeticNode readyCore = null; + for (final ArithmeticNode core : nodes) { + if (core != null) { + final Long timeCore; + timeCore = timeTable.containsKey(core) ? getTime(core) : 0L; + final Long timeReadyCore; + //noinspection IfMayBeConditional, nope, this is better + if ((readyCore != null) && timeTable.containsKey(readyCore)) { + timeReadyCore = getTime(readyCore); + } else { + timeReadyCore = 0L; + } + if ((readyCore == null) || (timeCore < timeReadyCore)) { + readyCore = core; + } + } + } + return Optional.of(readyCore); + } + + /** + * @param inMemory where is the data + * @param dataLink who should transfer data + * @param core destination of the data + * @param operationWithData what shall be done + * @return success. + */ + boolean transfer(MemoryNode inMemory, DataLink dataLink, ArithmeticNode core, + OperationWithData operationWithData) { + if (containsNull(inMemory, dataLink, core, operationWithData)) { + log.error("wrong input transfer({},{},{},{}), transfer failed!", + inMemory, dataLink.getName(), core, operationWithData); + return false; + } + + final Long time = dataLink.getTransferTime(operationWithData); + if (time != null) { + final Long start = findPossibleStart(inMemory, core, dataLink); + addTask(inMemory, start, time); + addTask(dataLink, start, time); + addTask(core, start, time); + journal.append("trans: ").append(inMemory.getName()).append("->") + .append(dataLink.getName()).append("->").append(core.getName()) + .append(" : ").append(operationWithData.getData().info()).append(' ') + .append(start).append("ms->").append(start + time).append("ms").append(LS); + return true; + } else { + log.error("wrong operation or wrong node, transfer failed!"); + return false; + } + } + + private long findPossibleStart(MemoryNode inMemory, ArithmeticNode core, DataLink dataLink) { + return Math.max(Math.max((timeTable.get(inMemory) != null) ? timeTable.get(inMemory) : 0L, + (timeTable.get(core) != null) ? timeTable.get(core) : 0L), + (timeTable.get(dataLink) != null) ? timeTable.get(dataLink) : 0L); + } + + /** + * @param component for whom we want timing + * @return when it should be free. + */ + @Nonnull + @Nonnegative + private Long getTime(ArchitectureComponent component) { + return (timeTable.get(component) != null) ? timeTable.get(component) : 0L; + } + + /** + * @param core who should work + * @param operationWithData what shall be done + * @return success. + */ + boolean calculate(ArithmeticNode core, OperationWithData operationWithData) { + if (containsNull(operationWithData, core)) { + log.error("wrong input calculate({},{}), calculation failed!", core, operationWithData); + return false; + } + + final Long time = core.getOperationTime(operationWithData); + if (time != null) { + final Long start = getTime(core); + addTask(core, start, time); + journal.append("comp: ").append(core.getName()).append(" : ") + .append(operationWithData.info()).append(start).append("ms->") + .append(start + time).append("ms").append(LS); + return true; + } else { + log.error("wrong operation or wrong node, calculate failed!"); + return false; + } + } +} diff --git a/src/main/java/simulation/control/package-info.java b/src/main/java/simulation/control/package-info.java new file mode 100644 index 0000000..b70ee06 --- /dev/null +++ b/src/main/java/simulation/control/package-info.java @@ -0,0 +1,23 @@ +/* + * Computer and algorithm interaction simulation software (CAISS). + * Copyright (C) 2016 Sergei Pomelov + * + * 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 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +/** + * @author Sergei Pomelov on 18.03.15. Objects wich contains logic of controlling computations + * processes and actors Additionally it represents journal of a computational process mailstones. + */ +package simulation.control; \ No newline at end of file diff --git a/src/main/java/simulation/package-info.java b/src/main/java/simulation/package-info.java new file mode 100644 index 0000000..ef70f0c --- /dev/null +++ b/src/main/java/simulation/package-info.java @@ -0,0 +1,23 @@ +/* + * Computer and algorithm interaction simulation software (CAISS). + * Copyright (C) 2016 Sergei Pomelov + * + * 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 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +/** + * @author Sergei Pomelov on 18.03.15. Computational process core. Contains representation of + * architecture and algorithm. Contains controllers of the process and it's actors. + */ +package simulation; \ No newline at end of file diff --git a/src/main/java/simulation/structures/algorithm/Algorithm.java b/src/main/java/simulation/structures/algorithm/Algorithm.java new file mode 100644 index 0000000..040337a --- /dev/null +++ b/src/main/java/simulation/structures/algorithm/Algorithm.java @@ -0,0 +1,54 @@ +/* + * Computer and algorithm interaction simulation software (CAISS). + * Copyright (C) 2016 Sergei Pomelov + * + * 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 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +package simulation.structures.algorithm; + + +import com.google.common.collect.ImmutableList; + +import java.io.Serializable; +import java.util.Collection; +import java.util.List; +import java.util.stream.Collectors; + +import javax.annotation.Nonnull; +import javax.annotation.concurrent.Immutable; + +/** + * @author Sergei Pomelov on 12.2.14 Graph like structure represents algorithm + */ +@SuppressWarnings("ReturnOfCollectionOrArrayField") +@Immutable +public final class Algorithm implements Serializable { + + private static final long serialVersionUID = -8563489136964513166L; + + /** algorithm graph */ + @Nonnull + private final List structure; + + public Algorithm(@Nonnull Collection structure) { + this.structure = ImmutableList.copyOf(structure.stream().filter(obj -> obj != null) + .collect(Collectors.toList())); + } + + @Nonnull + public Iterable getStructure() { + return structure; + } +} diff --git a/src/main/java/simulation/structures/algorithm/AlgorithmBuilder.java b/src/main/java/simulation/structures/algorithm/AlgorithmBuilder.java new file mode 100644 index 0000000..2f8d00c --- /dev/null +++ b/src/main/java/simulation/structures/algorithm/AlgorithmBuilder.java @@ -0,0 +1,75 @@ +/* + * Computer and algorithm interaction simulation software (CAISS). + * Copyright (C) 2016 Sergei Pomelov + * + * 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 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +package simulation.structures.algorithm; + +import java.io.Serializable; +import java.util.ArrayList; +import java.util.List; + +import javax.annotation.Nonnull; +import javax.annotation.concurrent.Immutable; + +import simulation.structures.interaction.DataBlock; +import simulation.structures.interaction.DataType; +import simulation.structures.interaction.OperationType; +import simulation.structures.interaction.OperationWithData; + +/** + * @author Sergei Pomelov on 12.2.14 utility class for build some algorith templates. + */ +@Immutable +public final class AlgorithmBuilder implements Serializable { + + private static final long serialVersionUID = 4170724840376687664L; + + private AlgorithmBuilder() { /*no public constructor*/ } + + /** + * @return parallel inversion template algorithm + */ + @Nonnull + public static Algorithm createAlgorithm() { + + final DataBlock subMatrix = new DataBlock("subArray", DataType.FOUR_B_FL, 500L * 500L); + + final OperationWithData subInverse = + new OperationWithData("invSmall", OperationType.INVERSE, subMatrix); + final OperationWithData transferSmall = + new OperationWithData("tr", OperationType.TRANSFER, subMatrix); + + final ArrayList in = new ArrayList<>(4); + final ArrayList out = new ArrayList<>(4); + + in.add(transferSmall); + in.add(transferSmall); + in.add(transferSmall); + in.add(transferSmall); + out.add(subInverse); + out.add(subInverse); + out.add(subInverse); + out.add(subInverse); + + final DataDependency dependency = + new DataDependency("data transfer", DependencyType.DATA_TRUE, in, out); + final List listDep = new ArrayList<>(1); + listDep.add(dependency); + + return new Algorithm(listDep); + } +} diff --git a/src/main/java/simulation/structures/algorithm/AlgorithmComponent.java b/src/main/java/simulation/structures/algorithm/AlgorithmComponent.java new file mode 100644 index 0000000..b6f8994 --- /dev/null +++ b/src/main/java/simulation/structures/algorithm/AlgorithmComponent.java @@ -0,0 +1,42 @@ +/* + * Computer and algorithm interaction simulation software (CAISS). + * Copyright (C) 2016 Sergei Pomelov + * + * 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 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +package simulation.structures.algorithm; + +import javax.annotation.Nonnull; + +import simulation.structures.commons.ComponentType; +import simulation.structures.commons.StructureElement; + +/** + * @author Sergei Pomelov on 2.5.14 basic Algorithm component + */ +public abstract class AlgorithmComponent extends StructureElement { + + private static final long serialVersionUID = -7277409404088617966L; + + AlgorithmComponent(@Nonnull final String name) { + super(name); + } + + @Nonnull + @Override + public final ComponentType getComponentType() { + return ComponentType.ALGORITHM; + } +} diff --git a/src/main/java/simulation/structures/algorithm/DataDependency.java b/src/main/java/simulation/structures/algorithm/DataDependency.java new file mode 100644 index 0000000..3b3b442 --- /dev/null +++ b/src/main/java/simulation/structures/algorithm/DataDependency.java @@ -0,0 +1,135 @@ +/* + * Computer and algorithm interaction simulation software (CAISS). + * Copyright (C) 2016 Sergei Pomelov + * + * 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 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +package simulation.structures.algorithm; + +import com.google.common.collect.ImmutableList; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +import javax.annotation.Nonnull; +import javax.annotation.ParametersAreNonnullByDefault; +import javax.annotation.concurrent.Immutable; + +import simulation.structures.interaction.DataBlock; +import simulation.structures.interaction.OperationWithData; + +import static util.Constants.LS; + +/** + * @author Sergei Pomelov on 2.10.14 dependencies on algorithm steps a.k.a. data flow dependencies + */ +@SuppressWarnings("ReturnOfCollectionOrArrayField") +@Immutable +@ParametersAreNonnullByDefault +public final class DataDependency extends AlgorithmComponent { + + private static final long serialVersionUID = 988170536445679820L; + private static final String LINK_CAP_OVERWHELMED = "Link cap overwhelmed"; + /** flow operation type */ + @Nonnull + private final DependencyType type; + /** flow start data */ + @Nonnull + private final List in; + /** flow end data */ + @Nonnull + private final List out; + + public DataDependency(DataDependency init) { + this(init.getName(), init.type, init.in, init.out); + } + + + /** + * @param inName name of transfer operation + * @param inType flow operation type + * @param inIn flow start data + * @param inOut low end data + */ + public DataDependency(String inName, DependencyType inType, + Collection inIn, Collection inOut) { + super(inName); + type = DependencyType.valueOf(inType.name()); + in = ImmutableList.copyOf(inIn); + out = ImmutableList.copyOf(inOut); + } + + @Nonnull + public OperationWithData getIn(int i) { + if (i >= in.size()) { + throw new IllegalArgumentException(LINK_CAP_OVERWHELMED); + } + return in.get(i); + } + + @Nonnull + public OperationWithData getOut(int i) { + if (i >= out.size()) { + throw new IllegalArgumentException(LINK_CAP_OVERWHELMED); + } + return out.get(i); + } + + @Nonnull + public Collection getUsedData() { + final Collection usedData = new ArrayList<>(10); + final Collection all = new ArrayList<>(in); + all.addAll(out); + all.forEach(el -> usedData.add(el.getData())); + return ImmutableList.copyOf(usedData); + } + + @Nonnull + @Override + public String info() { + final StringBuilder output = new StringBuilder(128); + output.append(LS).append(LS).append("Dependency - ") + .append(super.info()).append(':').append(type).append(':').append(LS); + + output.append(LS).append("In:").append(LS); + for (final OperationWithData el : in) { + output.append(String.format(" | %s", el.info())); + } + output.append(LS); + + output.append(LS).append("Out:").append(LS); + for (final OperationWithData el : out) { + output.append(String.format(" | %s", el.info())); + } + return output.toString(); + } + + @Nonnull + List getIn() { + return in; + } + + @Nonnull + List getOut() { + return out; + } + + @Nonnull + DependencyType getType() { + return type; + } + +} diff --git a/src/main/java/simulation/structures/algorithm/DependencyType.java b/src/main/java/simulation/structures/algorithm/DependencyType.java new file mode 100644 index 0000000..2b51ce5 --- /dev/null +++ b/src/main/java/simulation/structures/algorithm/DependencyType.java @@ -0,0 +1,26 @@ +/* + * Computer and algorithm interaction simulation software (CAISS). + * Copyright (C) 2016 Sergei Pomelov + * + * 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 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +package simulation.structures.algorithm; + +/** + * @author Sergei Pomelov on 2.10.14. + */ +enum DependencyType { + DATA_TRUE, DATA_FLOW, DATA_ANTI, CONTROL +} diff --git a/src/main/java/simulation/structures/algorithm/package-info.java b/src/main/java/simulation/structures/algorithm/package-info.java new file mode 100644 index 0000000..9dd2070 --- /dev/null +++ b/src/main/java/simulation/structures/algorithm/package-info.java @@ -0,0 +1,22 @@ +/* + * Computer and algorithm interaction simulation software (CAISS). + * Copyright (C) 2016 Sergei Pomelov + * + * 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 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +/** + * @author Sergei Pomelov on 18.03.15. Abstract algorith representation. + */ +package simulation.structures.algorithm; \ No newline at end of file diff --git a/src/main/java/simulation/structures/architecture/ArchitectureBuilder.java b/src/main/java/simulation/structures/architecture/ArchitectureBuilder.java new file mode 100644 index 0000000..862d694 --- /dev/null +++ b/src/main/java/simulation/structures/architecture/ArchitectureBuilder.java @@ -0,0 +1,164 @@ +/* + * Computer and algorithm interaction simulation software (CAISS). + * Copyright (C) 2016 Sergei Pomelov + * + * 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 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +package simulation.structures.architecture; + +import com.google.common.collect.ImmutableList; + +import java.io.Serializable; +import java.math.BigDecimal; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import java.util.Collections; +import java.util.List; + +import javax.annotation.Nonnull; +import javax.annotation.concurrent.Immutable; + +import simulation.structures.interaction.DataBlock; +import simulation.structures.interaction.DataType; +import simulation.structures.interaction.OperationPerformance; +import simulation.structures.interaction.OperationType; +import simulation.structures.interaction.OperationWithData; + +/** + * @author Sergei Pomelov on 12.2.14 + */ +@Immutable +public final class ArchitectureBuilder implements Serializable { + + private static final long serialVersionUID = -5424200034980053066L; + private static final String CORE_PERFORMANCE = "core performance"; + private static final String WHOLE_ARRAY = "wholeArray"; + private static final String INVERSE = "inverse"; + + private static final MemoryNode memory = new MemoryNode("DDR3", + new ArrayList<>(Collections.singletonList(DataType.EIGHT_B_FL)), + new ArrayList<>(Collections.singletonList(1000 * 1000)), + BigDecimal.valueOf(8L * 1000L * 1000L)); + + + private static final DataBlock matrix = + new DataBlock(WHOLE_ARRAY, DataType.FOUR_B_FL, 1000L * 1000L); + private static final DataBlock subMatrix = + new DataBlock("subArray", DataType.FOUR_B_FL, 500L * 500L); + + private static final OperationWithData inverseLarge = + new OperationWithData(INVERSE, OperationType.INVERSE, matrix); + private static final OperationWithData inverseSmall = + new OperationWithData(INVERSE, OperationType.INVERSE, subMatrix); + + private static final OperationPerformance inverseLargePerformance = + new OperationPerformance(CORE_PERFORMANCE, inverseLarge, 4000L); + private static final OperationPerformance inverseSmallPerformance = + new OperationPerformance(CORE_PERFORMANCE, inverseSmall, 2000L); + + private static final List speed; + + static { + Collection performances = new ArrayList<>(2); + performances.add(inverseLargePerformance); + performances.add(inverseSmallPerformance); + speed = ImmutableList.copyOf(performances); + } + + private ArchitectureBuilder() { /* utility class */ } + + + /** + * @return one core PC model + */ + @Nonnull + public static Computer buildFourCore() { + + final ArithmeticNode coreOne = new ArithmeticNode("Core1", speed); + final ArithmeticNode coreTwo = new ArithmeticNode("Core2", speed); + final ArithmeticNode coreThree = new ArithmeticNode("Core3", speed); + final ArithmeticNode coreFour = new ArithmeticNode("Core4", speed); + + final ArrayList inDataType = + new ArrayList<>(Collections.singletonList(DataType.FOUR_B_FL)); + final ArrayList inDataCapacity = + new ArrayList<>(Collections.singletonList(1000000)); + final ArrayList inDataTransferSpeed = + new ArrayList<>(Collections.singletonList(1000L)); + final ArrayList inIn = + new ArrayList<>(Collections.singletonList(memory)); + final ArrayList inOut = + new ArrayList<>(Arrays.asList(coreOne, coreTwo, coreThree, coreFour)); + + final DataLink bus = + new DataLink("bus", new DataLinkTransferCapabilities(inDataType, inDataCapacity, + inDataTransferSpeed, 4000L), inIn, inOut); + + return new Computer(Collections.singletonList(bus)); + } + + /** + * @return two core PC model + */ + @Nonnull + public static Computer buildTwoCore() { + final ArithmeticNode coreOne = new ArithmeticNode("Core1", speed); + final ArithmeticNode coreTwo = new ArithmeticNode("Core2", speed); + + + final ArrayList inDataType = + new ArrayList<>(Collections.singletonList(DataType.FOUR_B_FL)); + final ArrayList inDataCapacity = + new ArrayList<>(Collections.singletonList(1_000_000)); + final ArrayList inDataTransferSpeed = + new ArrayList<>(Collections.singletonList(1000L)); + final ArrayList inIn = + new ArrayList<>(Collections.singletonList(memory)); + final ArrayList inOut = + new ArrayList<>(Arrays.asList(coreOne, coreTwo)); + + final DataLink bus = new DataLink("bus", + new DataLinkTransferCapabilities(inDataType, inDataCapacity, + inDataTransferSpeed, 4000L), inIn, inOut); + + return new Computer(Collections.singletonList(bus)); + } + + /** + * @return four core PC model + */ + @Nonnull + public static Computer buildOneCore() { + final ArithmeticNode coreOne = new ArithmeticNode("Core1", speed); + + final ArrayList inDataType = + new ArrayList<>(Collections.singletonList(DataType.FOUR_B_FL)); + final ArrayList inDataCapacity = + new ArrayList<>(Collections.singletonList(1000 * 1000)); + final ArrayList inDataTransferSpeed = + new ArrayList<>(Collections.singletonList(1000L)); + final ArrayList inIn = + new ArrayList<>(Collections.singletonList(memory)); + final ArrayList inOut = + new ArrayList<>(Collections.singletonList(coreOne)); + + final DataLink bus = new DataLink("bus", + new DataLinkTransferCapabilities(inDataType, inDataCapacity, + inDataTransferSpeed, 4000L), inIn, inOut); + + return new Computer(Collections.singletonList(bus)); + } +} diff --git a/src/main/java/simulation/structures/architecture/ArchitectureComponent.java b/src/main/java/simulation/structures/architecture/ArchitectureComponent.java new file mode 100644 index 0000000..30c80b6 --- /dev/null +++ b/src/main/java/simulation/structures/architecture/ArchitectureComponent.java @@ -0,0 +1,45 @@ +/* + * Computer and algorithm interaction simulation software (CAISS). + * Copyright (C) 2016 Sergei Pomelov + * + * 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 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +package simulation.structures.architecture; + +import javax.annotation.Nonnull; + +import simulation.structures.commons.ComponentType; +import simulation.structures.commons.StructureElement; + +/** + * @author Sergei Pomelov on 12.5.14 basic Physical component + */ +public abstract class ArchitectureComponent extends StructureElement { + + private static final long serialVersionUID = -4700793405282367855L; + + ArchitectureComponent(@Nonnull final String name) { + super(name); + } + + @Nonnull + @Override + public final ComponentType getComponentType() { + return ComponentType.ARCHITECTURE; + } + + @Nonnull + protected abstract ArchitectureComponentType getArchitectureComponentType(); +} diff --git a/src/main/java/simulation/structures/architecture/ArchitectureComponentType.java b/src/main/java/simulation/structures/architecture/ArchitectureComponentType.java new file mode 100644 index 0000000..556619c --- /dev/null +++ b/src/main/java/simulation/structures/architecture/ArchitectureComponentType.java @@ -0,0 +1,26 @@ +/* + * Computer and algorithm interaction simulation software (CAISS). + * Copyright (C) 2016 Sergei Pomelov + * + * 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 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +package simulation.structures.architecture; + +/** + * @author Sergei Pomelov on 11.11.14. global computer components typing + */ +public enum ArchitectureComponentType { + ARITHMETIC_NODE, MEMORY_NODE, LINK +} diff --git a/src/main/java/simulation/structures/architecture/ArithmeticNode.java b/src/main/java/simulation/structures/architecture/ArithmeticNode.java new file mode 100644 index 0000000..27d7e25 --- /dev/null +++ b/src/main/java/simulation/structures/architecture/ArithmeticNode.java @@ -0,0 +1,98 @@ +/* + * Computer and algorithm interaction simulation software (CAISS). + * Copyright (C) 2016 Sergei Pomelov + * + * 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 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +package simulation.structures.architecture; + +import com.google.common.collect.ImmutableList; + +import java.util.Collection; +import java.util.List; + +import javax.annotation.Nonnull; +import javax.annotation.Nullable; +import javax.annotation.ParametersAreNonnullByDefault; +import javax.annotation.concurrent.Immutable; + +import simulation.structures.interaction.OperationPerformance; +import simulation.structures.interaction.OperationWithData; + +/** + * @author Sergei Pomelov on 2.5.14. Computation node or core + */ +@SuppressWarnings("ReturnOfCollectionOrArrayField") +@Immutable +@ParametersAreNonnullByDefault +public final class ArithmeticNode extends ArchitectureComponent { + + private static final long serialVersionUID = -2778594112555207896L; + @Nonnull + private final List allowedOperations; + + public ArithmeticNode(ArithmeticNode init) { + this(init.getName(), init.allowedOperations); + } + + public ArithmeticNode(String inName, Collection inAllowedOperations) { + super(inName); + allowedOperations = ImmutableList.copyOf(inAllowedOperations); + } + + @Nullable + public Long getOperationTime(OperationWithData operationWithData) { + for (final OperationPerformance oper : allowedOperations) { + if (oper.getOperation().getType() == operationWithData.getType()) { + final int i = allowedOperations.indexOf(oper); + return (long) (getAllowedOperation(i).getTime() * + ((float) operationWithData.getData().getSize() + / getAllowedOperation(i).getOperation().getData().getSize() + )); + } + } + return null; + } + + @Nonnull + public Collection getAllowedOperations() { + return allowedOperations; + } + + @Nonnull + @Override + public ArchitectureComponentType getArchitectureComponentType() { + return ArchitectureComponentType.ARITHMETIC_NODE; + } + + @Nonnull + @Override + public String info() { + final StringBuilder output = new StringBuilder(50); + output.append(String.format("%s :", super.info())); + for (final OperationPerformance operationPerformance : allowedOperations) { + output.append(String.format(" %s;", operationPerformance.info())); + } + return output.toString(); + } + + @Nonnull + private OperationPerformance getAllowedOperation(int i) { + if (i > allowedOperations.size()) { + throw new IllegalArgumentException("cap overwhelmed"); + } + return allowedOperations.get(i); + } +} diff --git a/src/main/java/simulation/structures/architecture/Computer.java b/src/main/java/simulation/structures/architecture/Computer.java new file mode 100644 index 0000000..b911495 --- /dev/null +++ b/src/main/java/simulation/structures/architecture/Computer.java @@ -0,0 +1,82 @@ +/* + * Computer and algorithm interaction simulation software (CAISS). + * Copyright (C) 2016 Sergei Pomelov + * + * 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 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +package simulation.structures.architecture; + +import com.google.common.collect.ImmutableList; + +import java.io.Serializable; +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +import javax.annotation.Nonnull; +import javax.annotation.concurrent.Immutable; + +import static util.ConversionUtil.nullFilter; + +/** + * @author Sergei Pomelov on 12.2.14. Computation node or core + */ +@SuppressWarnings("ReturnOfCollectionOrArrayField") +@Immutable +public final class Computer implements Serializable { + private static final long serialVersionUID = -7080364917126661958L; + @Nonnull + private final List architecture; // architecture graph + @Nonnull + private final List cores; // arithmetic nodes list + @Nonnull + private final List memory; // memory nodes list + + /** architecture graph */ + public Computer(@Nonnull final Collection structure) { + architecture = ImmutableList.copyOf(nullFilter(structure)); + + final Collection tempArchNodes = new ArrayList<>(5); + final Collection tempMemoryNodes = new ArrayList<>(1); + for (final DataLink dataLink : architecture) { + final Collection linkArNodes = dataLink.getArithmeticNodes(); + final Collection linkMemNodes = dataLink.getMemoryNodes(); + if (linkArNodes != null) { + tempArchNodes.addAll(linkArNodes); + } + if (linkMemNodes != null) { + tempMemoryNodes.addAll(linkMemNodes); + } + } + + cores = ImmutableList.copyOf(tempArchNodes); + memory = ImmutableList.copyOf(tempMemoryNodes); + } + + @Nonnull + public Iterable getArchitecture() { + return architecture; + } + + @Nonnull + public List getMemoryNodes() { + return memory; + } + + @Nonnull + public Collection getArchNodes() { + return cores; + } +} diff --git a/src/main/java/simulation/structures/architecture/DataLink.java b/src/main/java/simulation/structures/architecture/DataLink.java new file mode 100644 index 0000000..4225cbb --- /dev/null +++ b/src/main/java/simulation/structures/architecture/DataLink.java @@ -0,0 +1,222 @@ +/* + * Computer and algorithm interaction simulation software (CAISS). + * Copyright (C) 2016 Sergei Pomelov + * + * 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 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +package simulation.structures.architecture; + +import com.google.common.collect.ImmutableList; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +import javax.annotation.Nonnegative; +import javax.annotation.Nonnull; +import javax.annotation.Nullable; +import javax.annotation.ParametersAreNonnullByDefault; +import javax.annotation.concurrent.Immutable; + +import simulation.structures.interaction.DataType; +import simulation.structures.interaction.OperationType; +import simulation.structures.interaction.OperationWithData; + +import static util.Constants.LS; +import static util.ConversionUtil.nullFilter; + +/** + * @author Sergei Pomelov on 2.5.14. Link between components + */ +@SuppressWarnings("ReturnOfCollectionOrArrayField") +@Immutable +@ParametersAreNonnullByDefault +public final class DataLink extends ArchitectureComponent { + + private static final long serialVersionUID = -4090489770450876487L; + private static final String LINK_CAP_OVERWHELMED = "Link cap overwhelmed"; + + @Nonnull + private final DataLinkTransferCapabilities dataLinkTransferCapabilities; + @Nonnull + private final List in; + @Nonnull + private final List out; + + public DataLink(DataLink init) { + this(init.getName(), init.dataLinkTransferCapabilities, init.in, init.out); + } + + /** + * @param inName name of physical link + * @param inIn from where link can transfer + * @param inOut to where link can transfer + */ + public DataLink(String inName, + DataLinkTransferCapabilities dataLinkTransferCapabilities, + Collection inIn, + Collection inOut) { + super(inName); + this.dataLinkTransferCapabilities = dataLinkTransferCapabilities; + in = ImmutableList.copyOf(nullFilter(inIn)); + out = ImmutableList.copyOf(nullFilter(inOut)); + } + + @Nullable + public Long getTransferTime(OperationWithData operationWithData) { + if ((operationWithData.getType() == OperationType.TRANSFER) + && getDataType().contains(operationWithData.getData().getType())) { + final int i = getDataType().indexOf(operationWithData.getData().getType()); + return (long) (getDataTransferSpeed(i) * + ((float) operationWithData.getData().getSize() / getDataCapacity(i))); + } + return null; + } + + @Nonnull + public List getIn() { + return in; + } + + @Nonnull + public ArchitectureComponent getIn(int i) { + if (i >= in.size()) { + throw new IllegalArgumentException(LINK_CAP_OVERWHELMED); + } + return in.get(i); + } + + @Nonnull + public List getOut() { + return out; + } + + @Nonnull + public ArchitectureComponent getOut(int i) { + if (i >= out.size()) { + throw new IllegalArgumentException(LINK_CAP_OVERWHELMED); + } + return out.get(i); + } + + @Nullable + public Collection getArithmeticNodes() { + final Collection cores = new ArrayList<>(5); + final Collection all = new ArrayList<>(in); + all.addAll(out); + all.stream().filter(el -> + el.getArchitectureComponentType() == ArchitectureComponentType.ARITHMETIC_NODE) + .forEach(el -> { + final ArithmeticNode node = (ArithmeticNode) el; + cores.add(node); + }); + return ImmutableList.copyOf(cores); + } + + @Nullable + public Collection getMemoryNodes() { + final Collection memory = new ArrayList<>(1); + final Collection all = new ArrayList<>(in); + all.addAll(out); + + all.stream().filter(el -> + el.getArchitectureComponentType() == ArchitectureComponentType.MEMORY_NODE) + .forEach(el -> { + final MemoryNode node = (MemoryNode) el; + memory.add(node); + }); + return ImmutableList.copyOf(memory); + } + + @Nonnull + @Override + public ArchitectureComponentType getArchitectureComponentType() { + return ArchitectureComponentType.LINK; + } + + @Nonnull + @Override + public String info() { + final StringBuilder output = new StringBuilder(100); + output.append(LS).append(LS).append("Link - ").append(super.info()).append(' ') + .append(getDataByteCapacity()) + .append("b: "); + + for (final Long speed : getDataTransferSpeed()) { + final int i = getDataTransferSpeed().indexOf(speed); + output.append(String.format("| %s*%s - %smc ", getDataType(i).name(), + getDataCapacity(i).toString(), speed)); + } + output.append(LS); + + output.append(LS).append(" In: ").append(LS); + for (final ArchitectureComponent el : in) { + output.append(String.format("| %s ", el.info())); + } + output.append(LS); + + output.append(LS).append(" Out:").append(LS); + for (final ArchitectureComponent el : out) { + output.append(String.format("| %s ", el.info())); + } + return output.toString(); + } + + @Nonnull + private List getDataType() { + return dataLinkTransferCapabilities.getDataType(); + } + + @Nonnull + private List getDataCapacity() { + return dataLinkTransferCapabilities.getDataCapacity(); + } + + @Nonnull + @Nonnegative + private Integer getDataCapacity(int i) { + if (i >= getDataCapacity().size()) { + throw new IllegalArgumentException(LINK_CAP_OVERWHELMED); + } + return getDataCapacity().get(i); + } + + @Nonnull + private List getDataTransferSpeed() { + return dataLinkTransferCapabilities.getDataTransferSpeed(); + } + + @Nonnull + private Long getDataTransferSpeed(int i) { + if (i > getDataTransferSpeed().size()) { + throw new IllegalArgumentException(LINK_CAP_OVERWHELMED); + } + return getDataTransferSpeed().get(i); + } + + @Nonnull + private Long getDataByteCapacity() { + return dataLinkTransferCapabilities.getByteCapacity(); + } + + @Nonnull + private DataType getDataType(int i) { + if (i >= getDataType().size()) { + throw new IllegalArgumentException(LINK_CAP_OVERWHELMED); + } + return getDataType().get(i); + } + +} diff --git a/src/main/java/simulation/structures/architecture/DataLinkTransferCapabilities.java b/src/main/java/simulation/structures/architecture/DataLinkTransferCapabilities.java new file mode 100644 index 0000000..6c88dce --- /dev/null +++ b/src/main/java/simulation/structures/architecture/DataLinkTransferCapabilities.java @@ -0,0 +1,93 @@ +/* + * Computer and algorithm interaction simulation software (CAISS). + * Copyright (C) 2016 Sergei Pomelov + * + * 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 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +package simulation.structures.architecture; + +import com.google.common.collect.ImmutableList; + +import java.io.Serializable; +import java.util.Collection; +import java.util.List; + +import javax.annotation.Nonnegative; +import javax.annotation.Nonnull; +import javax.annotation.ParametersAreNonnullByDefault; +import javax.annotation.concurrent.Immutable; + +import simulation.structures.interaction.DataType; + +import static util.ConversionUtil.nullFilter; + +/** + * @author Sergey Pomelov on 15/04/2016. + */ +@SuppressWarnings("ReturnOfCollectionOrArrayField") +@Immutable +@ParametersAreNonnullByDefault +final class DataLinkTransferCapabilities implements Serializable { + + private static final long serialVersionUID = -5931373465895118508L; + + @Nonnull + private final List dataType; + @Nonnull + private final List dataCapacity; + @Nonnull + private final List dataTransferSpeed; + @Nonnull + @Nonnegative + private final Long byteCapacity; + + DataLinkTransferCapabilities(DataLinkTransferCapabilities init) { + this(init.dataType, init.dataCapacity, init.dataTransferSpeed, init.byteCapacity); + } + + /** + * @param dataType what data types link could transfer + * @param dataCapacity how much data we could transfer. Element number i means how much we can + * capacity type of {code inDataType.get(i)} + * @param byteCapacity how much physically data could be transferred + */ + DataLinkTransferCapabilities(Collection dataType, Collection dataCapacity, + Collection dataTransferSpeed, Long byteCapacity) { + this.dataType = ImmutableList.copyOf(nullFilter(dataType)); + this.dataCapacity = ImmutableList.copyOf(nullFilter(dataCapacity)); + this.dataTransferSpeed = ImmutableList.copyOf(nullFilter(dataTransferSpeed)); + this.byteCapacity = byteCapacity; + } + + @Nonnull + public List getDataType() { + return dataType; + } + + @Nonnull + public List getDataCapacity() { + return dataCapacity; + } + + @Nonnull + public List getDataTransferSpeed() { + return dataTransferSpeed; + } + + @Nonnull + public Long getByteCapacity() { + return byteCapacity; + } +} diff --git a/src/main/java/simulation/structures/architecture/MemoryNode.java b/src/main/java/simulation/structures/architecture/MemoryNode.java new file mode 100644 index 0000000..dd809eb --- /dev/null +++ b/src/main/java/simulation/structures/architecture/MemoryNode.java @@ -0,0 +1,115 @@ +/* + * Computer and algorithm interaction simulation software (CAISS). + * Copyright (C) 2016 Sergei Pomelov + * + * 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 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +package simulation.structures.architecture; + +import com.google.common.collect.ImmutableList; + +import java.math.BigDecimal; +import java.util.Collection; +import java.util.List; + +import javax.annotation.Nonnegative; +import javax.annotation.Nonnull; +import javax.annotation.ParametersAreNonnullByDefault; +import javax.annotation.concurrent.Immutable; + +import simulation.structures.interaction.DataType; + +/** + * @author Sergei Pomelov on 2.5.14. Operation Memory + */ +@SuppressWarnings("ReturnOfCollectionOrArrayField") +@Immutable +@ParametersAreNonnullByDefault +public final class MemoryNode extends ArchitectureComponent { + + private static final long serialVersionUID = 5900012936947627885L; + @Nonnull + @Nonnegative + private final BigDecimal byteCapacity; + @Nonnull + private final List dataType; + @Nonnull + private final List dataCapacity; + + public MemoryNode(MemoryNode init) { + this(init.getName(), init.dataType, init.dataCapacity, init.byteCapacity); + } + + public MemoryNode(String inName, Collection inDataType, + Collection inDataCapacity, @Nonnegative BigDecimal inByteCapacity) { + super(inName); + dataType = ImmutableList.copyOf(inDataType); + dataCapacity = ImmutableList.copyOf(inDataCapacity); + byteCapacity = inByteCapacity; + } + + @Nonnull + public DataType getDataType(final int i) { + if (i >= dataType.size()) { + throw new IllegalArgumentException("cap exceed"); + } + return dataType.get(i); + } + + @Nonnull + public List getDataTypeList() { + return dataType; + } + + @Nonnull + public List getDataCapacityList() { + return dataCapacity; + } + + @Nonnull + @Nonnegative + public BigDecimal getDataByteCapacity() { + return byteCapacity; + } + + @Nonnull + @Override + public ArchitectureComponentType getArchitectureComponentType() { + return ArchitectureComponentType.MEMORY_NODE; + } + + @Nonnull + @Override + public String info() { + final StringBuilder output = new StringBuilder(32); + output.append(String.format("%s %sb :", super.info(), byteCapacity)); + if (dataCapacity.size() == dataType.size()) { + dataType.forEach(dataTypeLocal -> output + .append(String.format(" %sX%s", + dataTypeLocal.name(), + getDataCapacity(dataType.indexOf(dataTypeLocal)).toString()))); + } + return output.toString(); + } + + @Nonnull + @Nonnegative + private Integer getDataCapacity(final int i) { + if (i >= dataType.size()) { + throw new IllegalArgumentException("cap exceed"); + } + return dataCapacity.get(i); + } +} diff --git a/src/main/java/simulation/structures/architecture/package-info.java b/src/main/java/simulation/structures/architecture/package-info.java new file mode 100644 index 0000000..ff9767c --- /dev/null +++ b/src/main/java/simulation/structures/architecture/package-info.java @@ -0,0 +1,22 @@ +/* + * Computer and algorithm interaction simulation software (CAISS). + * Copyright (C) 2016 Sergei Pomelov + * + * 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 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +/** + * @author Sergei Pomelov on 18.03.15. Abstract architecture representation. + */ +package simulation.structures.architecture; \ No newline at end of file diff --git a/src/main/java/simulation/structures/commons/ComponentType.java b/src/main/java/simulation/structures/commons/ComponentType.java new file mode 100644 index 0000000..ffe0ed6 --- /dev/null +++ b/src/main/java/simulation/structures/commons/ComponentType.java @@ -0,0 +1,24 @@ +/* + * Computer and algorithm interaction simulation software (CAISS). + * Copyright (C) 2016 Sergei Pomelov + * + * 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 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +package simulation.structures.commons; + +/* Created by Sergei Pomelov on 11.11.14. */ +public enum ComponentType { + ARCHITECTURE, ALGORITHM +} diff --git a/src/main/java/simulation/structures/commons/ComponentTyped.java b/src/main/java/simulation/structures/commons/ComponentTyped.java new file mode 100644 index 0000000..323feb9 --- /dev/null +++ b/src/main/java/simulation/structures/commons/ComponentTyped.java @@ -0,0 +1,27 @@ +/* + * Computer and algorithm interaction simulation software (CAISS). + * Copyright (C) 2016 Sergei Pomelov + * + * 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 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +package simulation.structures.commons; + +/** + * @author Sergei Pomelov on 11.11.14. + */ +@FunctionalInterface +interface ComponentTyped { + ComponentType getComponentType(); +} diff --git a/src/main/java/simulation/structures/commons/StructureElement.java b/src/main/java/simulation/structures/commons/StructureElement.java new file mode 100644 index 0000000..c285511 --- /dev/null +++ b/src/main/java/simulation/structures/commons/StructureElement.java @@ -0,0 +1,62 @@ +/* + * Computer and algorithm interaction simulation software (CAISS). + * Copyright (C) 2016 Sergei Pomelov + * + * 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 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +package simulation.structures.commons; + +import javax.annotation.Nonnegative; +import javax.annotation.Nonnull; + +import simulation.structures.interaction.SerializableElement; + +/** + * @author Sergei Pomelov on 11.11.14. Main computational process controller + */ +public abstract class StructureElement implements SerializableElement, ComponentTyped { + + private static final long serialVersionUID = 6086798332605789768L; + @Nonnull + private String name = ""; + + protected StructureElement(@Nonnull final String inName) { + name = inName; + } + + @Nonnull + @Nonnegative + @Override + public final Long getId() { + return 0L; + } + + @Nonnull + @Override + public final String getName() { + return name; + } + + @Nonnull + @Override + public String info() { + return name; + } + + @Override + public String toString() { + return info(); + } +} diff --git a/src/main/java/simulation/structures/commons/package-info.java b/src/main/java/simulation/structures/commons/package-info.java new file mode 100644 index 0000000..bbe2ef1 --- /dev/null +++ b/src/main/java/simulation/structures/commons/package-info.java @@ -0,0 +1,23 @@ +/* + * Computer and algorithm interaction simulation software (CAISS). + * Copyright (C) 2016 Sergei Pomelov + * + * 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 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +/** + * @author Sergei Pomelov on 18.03.15. Some components mutual for both algorithms and + * architectures. + */ +package simulation.structures.commons; \ No newline at end of file diff --git a/src/main/java/simulation/structures/interaction/ComputingObject.java b/src/main/java/simulation/structures/interaction/ComputingObject.java new file mode 100644 index 0000000..63e51bb --- /dev/null +++ b/src/main/java/simulation/structures/interaction/ComputingObject.java @@ -0,0 +1,62 @@ +/* + * Computer and algorithm interaction simulation software (CAISS). + * Copyright (C) 2016 Sergei Pomelov + * + * 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 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +package simulation.structures.interaction; + +import javax.annotation.Nonnegative; +import javax.annotation.Nonnull; + +/** + * @author Sergei Pomelov on 2.5.14. Computational abstract actor + */ +abstract class ComputingObject implements SerializableElement { + + private static final long serialVersionUID = 6086798332605789768L; + /** id for future DB */ + @Nonnull + @Nonnegative + private static final Long id = 0L; + /** human-friendly name */ + @Nonnull + private final String name; + + /** @param inName ordinary human-friendly name of the object */ + ComputingObject(@Nonnull final String inName) { + name = inName; + } + + @Nonnull + @Nonnegative + @Override + public final Long getId() { + return id; + } + + @Nonnull + @Override + public final String getName() { + return name; + } + + /** @return human-friendly formatted information about the object */ + @Nonnull + @Override + public String info() { + return name; + } +} diff --git a/src/main/java/simulation/structures/interaction/DataBlock.java b/src/main/java/simulation/structures/interaction/DataBlock.java new file mode 100644 index 0000000..ef60570 --- /dev/null +++ b/src/main/java/simulation/structures/interaction/DataBlock.java @@ -0,0 +1,93 @@ +/* + * Computer and algorithm interaction simulation software (CAISS). + * Copyright (C) 2016 Sergei Pomelov + * + * 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 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +package simulation.structures.interaction; + + +import javax.annotation.Nonnegative; +import javax.annotation.Nonnull; +import javax.annotation.ParametersAreNonnullByDefault; +import javax.annotation.concurrent.Immutable; + +/** + * @author Sergei Pomelov on 2.5.14. Data representation + */ +@Immutable +@ParametersAreNonnullByDefault +public final class DataBlock extends ComputingObject { + + private static final long serialVersionUID = 2834169680429419028L; + /** type of contained data */ + @Nonnull + private final DataType type; + /** how many data objects of this type are contained here */ + @Nonnull + @Nonnegative + private final Long size; + + private DataBlock() { + this("ZeroMemory", DataType.EIGHT_B_FL, 0L); + } + + /** @param init DataBlock for copying */ + public DataBlock(final DataBlock init) { + this(init.getName(), init.type, init.size); + } + + /** + * @param inName ordinary human-friendly name of the object + * @param inType type of contained data + * @param inSize how many data objects of this type are contained here + */ + public DataBlock(final String inName, final DataType inType, @Nonnegative final Long inSize) { + super(inName); + if (inSize <= 0L) { + throw new IllegalArgumentException("Wrong inSize for createAlgorithm DataBlock"); + } + type = DataType.valueOf(inType.name()); + size = inSize; + } + + @Nonnull + public DataType getType() { + return type; + } + + @Nonnull + @Nonnegative + public Long getSize() { + return size; + } + + @Override + public boolean equals(final Object obj) { + return (obj instanceof DataBlock) && ((((DataBlock) obj).type == type) + && (((DataBlock) obj).size.equals(size))); + } + + @Override + public int hashCode() { + return type.ordinal() + size.intValue(); + } + + @Override + @Nonnull + public String info() { + return String.format("%s {%s*%s}", super.info(), type.name(), size.toString()); + } +} diff --git a/src/main/java/simulation/structures/interaction/DataType.java b/src/main/java/simulation/structures/interaction/DataType.java new file mode 100644 index 0000000..26282fc --- /dev/null +++ b/src/main/java/simulation/structures/interaction/DataType.java @@ -0,0 +1,27 @@ +/* + * Computer and algorithm interaction simulation software (CAISS). + * Copyright (C) 2016 Sergei Pomelov + * + * 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 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +package simulation.structures.interaction; + +/** + * @author Sergey Pomelov on 2.10.14. Data types list + */ +public enum DataType { + BOOL, B_DEC, TWO_B_DEC, FOUR_B_DEC, EIGHT_B_DEC, SIXTEEN_B_DEC, + ONE_B_FL, TWO_B_FL, FOUR_B_FL, EIGHT_B_FL, SIXTEEN_B_FL +} diff --git a/src/main/java/simulation/structures/interaction/OperationPerformance.java b/src/main/java/simulation/structures/interaction/OperationPerformance.java new file mode 100644 index 0000000..54d3673 --- /dev/null +++ b/src/main/java/simulation/structures/interaction/OperationPerformance.java @@ -0,0 +1,77 @@ +/* + * Computer and algorithm interaction simulation software (CAISS). + * Copyright (C) 2016 Sergei Pomelov + * + * 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 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +package simulation.structures.interaction; + + +import javax.annotation.Nonnegative; +import javax.annotation.Nonnull; +import javax.annotation.ParametersAreNonnullByDefault; +import javax.annotation.concurrent.Immutable; + +/** + * @author Sergei Pomelov on 2.5.14. Representation of how fast we can do this OperationwithData + * @see OperationWithData + */ +@Immutable +@ParametersAreNonnullByDefault +public final class OperationPerformance extends ComputingObject { + + private static final long serialVersionUID = -5609898011539390298L; + + @Nonnull + private final OperationWithData oper; // what we do + @Nonnull + @Nonnegative + private final Long time; // how fast + + OperationPerformance() { + this("ZeroOperationPerformance", new OperationWithData(), 0L); + } + + public OperationPerformance(OperationPerformance inOperation) { + this(inOperation.getName(), inOperation.oper, inOperation.time); + } + + /** + * @param inOper which operation + * @param inTime how fast we can do it + */ + public OperationPerformance(String inName, OperationWithData inOper, Long inTime) { + super(inName); + oper = new OperationWithData(inOper); + time = inTime; + } + + @Nonnull + public OperationWithData getOperation() { + return oper; + } + + @Nonnull + @Nonnegative + public Long getTime() { + return time; + } + + @Nonnull + @Override + public String info() { + return (String.format("%s(%s) t=%smc", super.info(), oper.info(), time.toString())); + } +} diff --git a/src/main/java/simulation/structures/interaction/OperationType.java b/src/main/java/simulation/structures/interaction/OperationType.java new file mode 100644 index 0000000..ddbac7d --- /dev/null +++ b/src/main/java/simulation/structures/interaction/OperationType.java @@ -0,0 +1,26 @@ +/* + * Computer and algorithm interaction simulation software (CAISS). + * Copyright (C) 2016 Sergei Pomelov + * + * 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 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +package simulation.structures.interaction; + +/** + * @author Sergey Pomelov on 2.10.14. computational operations types + */ +public enum OperationType { + INVERSE, ADDITION, TRANSPOSE, TRANSFER, NONE +} diff --git a/src/main/java/simulation/structures/interaction/OperationWithData.java b/src/main/java/simulation/structures/interaction/OperationWithData.java new file mode 100644 index 0000000..f5c2f17 --- /dev/null +++ b/src/main/java/simulation/structures/interaction/OperationWithData.java @@ -0,0 +1,78 @@ +/* + * Computer and algorithm interaction simulation software (CAISS). + * Copyright (C) 2016 Sergei Pomelov + * + * 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 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +package simulation.structures.interaction; + + +import javax.annotation.Nonnull; +import javax.annotation.ParametersAreNonnullByDefault; +import javax.annotation.concurrent.Immutable; + +/** + * @author Sergei Pomelov on 2.5.14. + */ +@Immutable +@ParametersAreNonnullByDefault +public final class OperationWithData extends ComputingObject { + + private static final long serialVersionUID = 5318763246120708102L; + @Nonnull + private final OperationType type; // what we do + @Nonnull + private final DataBlock data; // with what + + + OperationWithData() { + this("ZeroOperation", + OperationType.ADDITION, + new DataBlock("ZeroDataBlock", DataType.BOOL, 0L)); + } + + public OperationWithData(OperationWithData init) { + this(init.getName(), init.type, init.data); + } + + /** + * @param inType which operation + * @param inData how fast we can do it + */ + public OperationWithData(String inName, OperationType inType, DataBlock inData) { + super(inName); + if (inData.getSize() <= 0) { + throw new IllegalArgumentException("Wrong inData for createAlgorithm Operation"); + } + type = OperationType.valueOf(inType.name()); + data = new DataBlock(inData); + } + + @Nonnull + public OperationType getType() { + return type; + } + + @Nonnull + public DataBlock getData() { + return data; + } + + @Nonnull + @Override + public String info() { + return (String.format("%s-%s %s", super.info(), type, data.info())); + } +} diff --git a/src/main/java/simulation/structures/interaction/SerializableElement.java b/src/main/java/simulation/structures/interaction/SerializableElement.java new file mode 100644 index 0000000..0044d79 --- /dev/null +++ b/src/main/java/simulation/structures/interaction/SerializableElement.java @@ -0,0 +1,38 @@ +/* + * Computer and algorithm interaction simulation software (CAISS). + * Copyright (C) 2016 Sergei Pomelov + * + * 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 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +package simulation.structures.interaction; + +import java.io.Serializable; + +import javax.annotation.Nonnull; + +/** + * @author Sergei Pomelov on 12.2.14. + */ +public interface SerializableElement extends Serializable { + + @Nonnull + Long getId(); + + @Nonnull + String getName(); + + @Nonnull + String info(); +} diff --git a/src/main/java/simulation/structures/interaction/package-info.java b/src/main/java/simulation/structures/interaction/package-info.java new file mode 100644 index 0000000..3b61d43 --- /dev/null +++ b/src/main/java/simulation/structures/interaction/package-info.java @@ -0,0 +1,22 @@ +/* + * Computer and algorithm interaction simulation software (CAISS). + * Copyright (C) 2016 Sergei Pomelov + * + * 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 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +/** + * @author Sergei Pomelov on 18.03.15. Objects wich represents actors in computations process + */ +package simulation.structures.interaction; \ No newline at end of file diff --git a/src/main/java/util/Constants.java b/src/main/java/util/Constants.java new file mode 100644 index 0000000..5ea7de9 --- /dev/null +++ b/src/main/java/util/Constants.java @@ -0,0 +1,34 @@ +/* + * Computer and algorithm interaction simulation software (CAISS). + * Copyright (C) 2016 Sergei Pomelov + * + * 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 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +package util; + +/** + * @author Sergey Pomelov on 12.03.15. + */ +public final class Constants { + public static final String LS = System.lineSeparator().intern(); + public static final String GNU_COPYRIGHT_MSG = + " Computer and algorithm interaction simulation software (CAISS)." + LS + + " Copyright (C) " + TimeUtil.getCurrentYear() + " Pomelov Sergey Valer'evich." + LS + + " This program comes with ABSOLUTELY NO WARRANTY." + LS + + " This is free software, and you are welcome to redistribute it" + LS + + " under certain conditions. For details go to ."; + + private Constants() { /*utility class*/ } +} diff --git a/src/main/java/util/ConversionUtil.java b/src/main/java/util/ConversionUtil.java new file mode 100644 index 0000000..aabd3f4 --- /dev/null +++ b/src/main/java/util/ConversionUtil.java @@ -0,0 +1,40 @@ +/* + * Computer and algorithm interaction simulation software (CAISS). + * Copyright (C) 2016 Sergei Pomelov + * + * 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 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +package util; + +import java.util.Collection; +import java.util.stream.Collectors; + +/** + * @author Sergey Pomelov on 15/04/2016. + */ +public final class ConversionUtil { + + private static final int BYTES_IN_MEGABYTES = 1024 * 1024; + + private ConversionUtil() { /* utility class */ } + + public static long bytesToMb(long bytes) { + return bytes / BYTES_IN_MEGABYTES; + } + + public static Collection nullFilter(Collection collection) { + return collection.stream().filter(obj -> obj != null).collect(Collectors.toList()); + } +} diff --git a/src/main/java/util/Restrictions.java b/src/main/java/util/Restrictions.java new file mode 100644 index 0000000..735fb71 --- /dev/null +++ b/src/main/java/util/Restrictions.java @@ -0,0 +1,53 @@ +/* + * Computer and algorithm interaction simulation software (CAISS). + * Copyright (C) 2016 Sergei Pomelov + * + * 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 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +package util; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.util.Arrays; + +/** + * @author Sergey Pomelov on 15/04/2016. + */ +public final class Restrictions { + + private static final Logger log = LoggerFactory.getLogger(Restrictions.class); + + private Restrictions() { /* util class */ } + + public static void ifContainsNullFastFail(Object... objects) { + for (Object object : objects) { + if (object == null) { + throw new IllegalArgumentException("Objects: " + Arrays.toString(objects) + + "contain null!"); + } + } + } + + public static boolean containsNull(Object... objects) { + for (Object object : objects) { + if (object == null) { + log.error("Objects: {} contain null!", Arrays.toString(objects)); + return true; + } + } + return false; + } +} diff --git a/src/main/java/util/TimeUtil.java b/src/main/java/util/TimeUtil.java new file mode 100644 index 0000000..d739dd6 --- /dev/null +++ b/src/main/java/util/TimeUtil.java @@ -0,0 +1,38 @@ +/* + * Computer and algorithm interaction simulation software (CAISS). + * Copyright (C) 2016 Sergei Pomelov + * + * 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 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +package util; + +import java.util.Calendar; +import java.util.concurrent.TimeUnit; + +/** + * @author Sergey Pomelov on 15/04/2016. + */ +public final class TimeUtil { + + private TimeUtil() { /* utility class */ } + + public static int getCurrentYear() { + return Calendar.getInstance().get(Calendar.YEAR); + } + + public static long nanoToMls(long nano) { + return TimeUnit.NANOSECONDS.toMillis(nano); + } +} diff --git a/src/main/resources/logback.xml b/src/main/resources/logback.xml new file mode 100644 index 0000000..4370ccc --- /dev/null +++ b/src/main/resources/logback.xml @@ -0,0 +1,33 @@ + + + + + + + + %d{HH:mm:ss.SSS} %-5level [%thread | %logger{1}]: %msg%n + + + + + + + + + diff --git a/src/test/java/simulation/control/SimulationControllerTest.java b/src/test/java/simulation/control/SimulationControllerTest.java new file mode 100644 index 0000000..8e0e89f --- /dev/null +++ b/src/test/java/simulation/control/SimulationControllerTest.java @@ -0,0 +1,41 @@ +/* + * Computer and algorithm interaction simulation software (CAISS). + * Copyright (C) 2016 Sergei Pomelov + * + * 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 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +package simulation.control; + +import org.junit.Test; + +import static org.junit.Assert.assertFalse; + +/** + * ControllerImpl Tester. + * + * @author + * @version 1.0 + * @since 
Apr 17, 2015
+ */ +public class SimulationControllerTest { + + /** + * Method: simulate() + */ + @Test + public void testSimulate() { + assertFalse(new SimulationController().simulate().isEmpty()); + } +} diff --git a/src/test/java/simulation/control/TasksPlannerTest.java b/src/test/java/simulation/control/TasksPlannerTest.java new file mode 100644 index 0000000..36076d5 --- /dev/null +++ b/src/test/java/simulation/control/TasksPlannerTest.java @@ -0,0 +1,96 @@ +/* + * Computer and algorithm interaction simulation software (CAISS). + * Copyright (C) 2016 Sergei Pomelov + * + * 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 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +package simulation.control; + +import org.junit.Test; + +import simulation.structures.architecture.ArchitectureBuilder; +import simulation.structures.architecture.ArithmeticNode; +import simulation.structures.architecture.Computer; +import simulation.structures.architecture.DataLink; +import simulation.structures.interaction.DataBlock; +import simulation.structures.interaction.DataType; +import simulation.structures.interaction.OperationType; +import simulation.structures.interaction.OperationWithData; + +import static junit.framework.TestCase.assertNotNull; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; + +/** + * Gunt Tester. + * + * @author + * @version 1.0 + * @since 
Apr 17, 2015
+ */ +@SuppressWarnings({"ConstantConditions", "OptionalGetWithoutIsPresent"}) +public class TasksPlannerTest { + + @Test + public void testLoad() { + final TasksPlanner tasksPlanner = new TasksPlanner(ArchitectureBuilder.buildOneCore()); + assertTrue(tasksPlanner.getLog().isEmpty()); + assertEquals(1, tasksPlanner.getArchNodes().size()); + assertEquals(1, tasksPlanner.getMemoryNodes().size()); + } + + @Test + public void testLoadIndependency() { + final TasksPlanner tasksPlanner = new TasksPlanner(ArchitectureBuilder.buildOneCore()); + tasksPlanner.load(ArchitectureBuilder.buildOneCore()); + assertTrue(tasksPlanner.getLog().isEmpty()); + assertEquals(1, tasksPlanner.getArchNodes().size()); + assertEquals(1, tasksPlanner.getMemoryNodes().size()); + tasksPlanner.load(ArchitectureBuilder.buildTwoCore()); + assertTrue(tasksPlanner.getLog().isEmpty()); + assertEquals(2, tasksPlanner.getArchNodes().size()); + assertEquals(1, tasksPlanner.getMemoryNodes().size()); + } + + /** + * Method: getJournal() + */ + @Test + public void testGetLog() { + final TasksPlanner tasksPlanner = new TasksPlanner(ArchitectureBuilder.buildOneCore()); + final Computer comp = ArchitectureBuilder.buildOneCore(); + final ArithmeticNode core = tasksPlanner.getFreeArNode(comp.getArchNodes()).get(); + final DataBlock subMatrix = new DataBlock("subArray", DataType.FOUR_B_FL, 500L * 500L); + final OperationWithData subInverse = + new OperationWithData("inverse", OperationType.INVERSE, subMatrix); + final OperationWithData transferSmall = + new OperationWithData("inverse", OperationType.TRANSFER, subMatrix); + final DataLink dataLink = comp.getArchitecture().iterator().next(); + + tasksPlanner.load(comp); + tasksPlanner.transfer(comp.getMemoryNodes().get(0), dataLink, core, transferSmall); + tasksPlanner.calculate(core, subInverse); + assertNotNull(tasksPlanner.getFreeArNode(comp.getArchNodes())); + assertFalse(tasksPlanner.getLog().isEmpty()); + } + + @Test + public void testFreeArNode() { + final TasksPlanner tasksPlanner = new TasksPlanner(ArchitectureBuilder.buildOneCore()); + final Computer comp = ArchitectureBuilder.buildOneCore(); + assertNotNull(tasksPlanner.getFreeArNode(comp.getArchNodes())); + } +} diff --git a/src/test/java/simulation/structures/interaction/DataBlockTest.java b/src/test/java/simulation/structures/interaction/DataBlockTest.java new file mode 100644 index 0000000..c190474 --- /dev/null +++ b/src/test/java/simulation/structures/interaction/DataBlockTest.java @@ -0,0 +1,75 @@ +/* + * Computer and algorithm interaction simulation software (CAISS). + * Copyright (C) 2016 Sergei Pomelov + * + * 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 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +package simulation.structures.interaction; + +import org.junit.Test; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotSame; +import static org.junit.Assert.assertTrue; + +/** + * DataBlock Tester. + * + * @author created by Sergei Pomelov on 12.03.15. + */ +public class DataBlockTest { + + private final DataBlock data1 = new DataBlock("1", DataType.B_DEC, 2L); + + @Test + public void testBadSize() { + boolean thrown = false; + try { + new DataBlock("1", DataType.B_DEC, -1L); + } catch (IllegalArgumentException ignored) { + thrown = true; + } + assertTrue(thrown); + } + + @Test + public void testEquals() { + DataBlock data2 = new DataBlock("1", DataType.B_DEC, 2L); + assertEquals(data1, data2); + } + + @Test + public void testEqualsBack() { + DataBlock data2 = new DataBlock("1", DataType.B_DEC, 2L); + assertEquals(data2, data1); + } + + @Test + public void testEqualsReflective() { + assertEquals(data1, data1); + } + + @Test + public void testEqualsCopy() { + DataBlock data2 = new DataBlock(data1); + assertEquals(data1, data2); + } + + @Test + public void testNotReferenceCopy() { + DataBlock data2 = new DataBlock(data1); + assertNotSame(data1, data2); + } +}