mirror of
https://github.com/Dr-Noob/cpufetch.git
synced 2026-03-25 16:00:39 +01:00
Compare commits
1 Commits
fix-accura
...
outfile
| Author | SHA1 | Date | |
|---|---|---|---|
|
b02d3d6d11 |
36
.github/workflows/lockdown.yml
vendored
36
.github/workflows/lockdown.yml
vendored
@@ -1,36 +0,0 @@
|
||||
name: 'Disable PR in cpufetch'
|
||||
|
||||
on:
|
||||
issues:
|
||||
types: opened
|
||||
pull_request_target:
|
||||
types: opened
|
||||
|
||||
permissions:
|
||||
issues: write
|
||||
pull-requests: write
|
||||
|
||||
jobs:
|
||||
action:
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- uses: dessant/repo-lockdown@v2
|
||||
with:
|
||||
github-token: ${{ github.token }}
|
||||
exclude-issue-created-before: ''
|
||||
exclude-issue-labels: ''
|
||||
issue-labels: ''
|
||||
issue-comment: ''
|
||||
skip-closed-issue-comment: false
|
||||
close-issue: false
|
||||
lock-issue: true
|
||||
issue-lock-reason: ''
|
||||
exclude-pr-created-before: ''
|
||||
exclude-pr-labels: ''
|
||||
pr-labels: ''
|
||||
pr-comment: 'cpufetch does not accept pull requests, see [the contributing guidelines](https://github.com/Dr-Noob/cpufetch/blob/master/CONTRIBUTING.md) for details'
|
||||
skip-closed-pr-comment: false
|
||||
close-pr: true
|
||||
lock-pr: false
|
||||
pr-lock-reason: ''
|
||||
process-only: 'prs'
|
||||
1
.gitignore
vendored
1
.gitignore
vendored
@@ -1,2 +1 @@
|
||||
cpufetch
|
||||
*.o
|
||||
|
||||
@@ -1,52 +0,0 @@
|
||||
# cpufetch contributing guidelines
|
||||
|
||||
<!-- START doctoc generated TOC please keep comment here to allow auto update -->
|
||||
<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->
|
||||
|
||||
- [1. cpufetch does not accept pull requests](#1-cpufetch-does-not-accept-pull-requests)
|
||||
- [2. Creating an issue](#2-creating-an-issue)
|
||||
- [2.1: I found a bug in cpufetch (the program provides incorrect / invalid information)](#21-i-found-a-bug-in-cpufetch-the-program-provides-incorrect--invalid-information)
|
||||
- [2.2: I found a bug in cpufetch (the program crashes / does not work properly)](#22-i-found-a-bug-in-cpufetch-the-program-crashes--does-not-work-properly)
|
||||
- [Stacktrace option 1 (best)](#stacktrace-option-1-best)
|
||||
- [Stacktrace option 2 (use this option if option 1 does not work)](#stacktrace-option-2-use-this-option-if-option-1-does-not-work)
|
||||
- [2.3: I have an idea for a new feature in cpufetch / I want to suggest a change in cpufetch](#23-i-have-an-idea-for-a-new-feature-in-cpufetch--i-want-to-suggest-a-change-in-cpufetch)
|
||||
|
||||
<!-- END doctoc generated TOC please keep comment here to allow auto update -->
|
||||
Thanks for your interest in contributing to cpufetch! Please, read this page carefully to understand how to contribute to cpufetch.
|
||||
|
||||
## 1. cpufetch does not accept pull requests
|
||||
cpufetch is a small project, and I enjoy developing it. There are for sure some bugs and exciting features to add, but I prefer to make these
|
||||
changes myself. For that reason, you should always use the issues page to report anything related to cpufetch. In the rare case that there is
|
||||
a concise bug or feature that I am unable to implement myself, I will enable pull requests for this.
|
||||
|
||||
## 2. Creating an issue
|
||||
|
||||
### 2.1: I found a bug in cpufetch (the program provides incorrect / invalid information)
|
||||
In the github issue **you must include**:
|
||||
- Exact CPU model.
|
||||
- Operating system.
|
||||
- The output of `cpufetch`.
|
||||
- The output of `cpufetch --debug`.
|
||||
|
||||
### 2.2: I found a bug in cpufetch (the program crashes / does not work properly)
|
||||
- Exact CPU model.
|
||||
- Operating system.
|
||||
- The output of `cpufetch`.
|
||||
- The output of `cpufetch --debug`.
|
||||
- A stacktrace (if program crashes):
|
||||
|
||||
#### Stacktrace option 1 (best)
|
||||
1. Build cpufetch with debug symbols (`make clean; make debug`).
|
||||
2. Install valgrind (if it is not already installed)
|
||||
3. Run cpufetch with valgrind (`valgrind ./cpufetch`)
|
||||
4. Paste the complete output (preferably on a platform like pastebin)
|
||||
|
||||
#### Stacktrace option 2 (use this option if option 1 does not work)
|
||||
1. Build cpufetch with debug symbols (`make clean; make debug`).
|
||||
2. Install gdb (if it is not already installed)
|
||||
3. Debug cpufetch with gdb (`gdb cpufetch`)
|
||||
3. Run cpufetch (just r inside gdb console)
|
||||
4. Paste the complete output (preferably on a platform like pastebin)
|
||||
|
||||
### 2.3: I have an idea for a new feature in cpufetch / I want to suggest a change in cpufetch
|
||||
Just explain the feature in the issue and include references (links) to relevant sources if appropriate.
|
||||
352
LICENSE
352
LICENSE
@@ -1,339 +1,21 @@
|
||||
GNU GENERAL PUBLIC LICENSE
|
||||
Version 2, June 1991
|
||||
MIT License
|
||||
|
||||
Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
Everyone is permitted to copy and distribute verbatim copies
|
||||
of this license document, but changing it is not allowed.
|
||||
Copyright (c) 2018 Dr-Noob
|
||||
|
||||
Preamble
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The licenses for most software are designed to take away your
|
||||
freedom to share and change it. By contrast, the GNU General Public
|
||||
License is intended to guarantee your freedom to share and change free
|
||||
software--to make sure the software is free for all its users. This
|
||||
General Public License applies to most of the Free Software
|
||||
Foundation's software and to any other program whose authors commit to
|
||||
using it. (Some other Free Software Foundation software is covered by
|
||||
the GNU Lesser General Public License instead.) You can apply it to
|
||||
your programs, too.
|
||||
The above copyright notice and this permission notice shall be included in all
|
||||
copies or substantial portions of the Software.
|
||||
|
||||
When we speak of free software, we are referring to freedom, not
|
||||
price. Our General Public Licenses are designed to make sure that you
|
||||
have the freedom to distribute copies of free software (and charge for
|
||||
this service if you wish), that you receive source code or can get it
|
||||
if you want it, that you can change the software or use pieces of it
|
||||
in new free programs; and that you know you can do these things.
|
||||
|
||||
To protect your rights, we need to make restrictions that forbid
|
||||
anyone to deny you these rights or to ask you to surrender the rights.
|
||||
These restrictions translate to certain responsibilities for you if you
|
||||
distribute copies of the software, or if you modify it.
|
||||
|
||||
For example, if you distribute copies of such a program, whether
|
||||
gratis or for a fee, you must give the recipients all the rights that
|
||||
you have. You must make sure that they, too, receive or can get the
|
||||
source code. And you must show them these terms so they know their
|
||||
rights.
|
||||
|
||||
We protect your rights with two steps: (1) copyright the software, and
|
||||
(2) offer you this license which gives you legal permission to copy,
|
||||
distribute and/or modify the software.
|
||||
|
||||
Also, for each author's protection and ours, we want to make certain
|
||||
that everyone understands that there is no warranty for this free
|
||||
software. If the software is modified by someone else and passed on, we
|
||||
want its recipients to know that what they have is not the original, so
|
||||
that any problems introduced by others will not reflect on the original
|
||||
authors' reputations.
|
||||
|
||||
Finally, any free program is threatened constantly by software
|
||||
patents. We wish to avoid the danger that redistributors of a free
|
||||
program will individually obtain patent licenses, in effect making the
|
||||
program proprietary. To prevent this, we have made it clear that any
|
||||
patent must be licensed for everyone's free use or not licensed at all.
|
||||
|
||||
The precise terms and conditions for copying, distribution and
|
||||
modification follow.
|
||||
|
||||
GNU GENERAL PUBLIC LICENSE
|
||||
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
|
||||
|
||||
0. This License applies to any program or other work which contains
|
||||
a notice placed by the copyright holder saying it may be distributed
|
||||
under the terms of this General Public License. The "Program", below,
|
||||
refers to any such program or work, and a "work based on the Program"
|
||||
means either the Program or any derivative work under copyright law:
|
||||
that is to say, a work containing the Program or a portion of it,
|
||||
either verbatim or with modifications and/or translated into another
|
||||
language. (Hereinafter, translation is included without limitation in
|
||||
the term "modification".) Each licensee is addressed as "you".
|
||||
|
||||
Activities other than copying, distribution and modification are not
|
||||
covered by this License; they are outside its scope. The act of
|
||||
running the Program is not restricted, and the output from the Program
|
||||
is covered only if its contents constitute a work based on the
|
||||
Program (independent of having been made by running the Program).
|
||||
Whether that is true depends on what the Program does.
|
||||
|
||||
1. You may copy and distribute verbatim copies of the Program's
|
||||
source code as you receive it, in any medium, provided that you
|
||||
conspicuously and appropriately publish on each copy an appropriate
|
||||
copyright notice and disclaimer of warranty; keep intact all the
|
||||
notices that refer to this License and to the absence of any warranty;
|
||||
and give any other recipients of the Program a copy of this License
|
||||
along with the Program.
|
||||
|
||||
You may charge a fee for the physical act of transferring a copy, and
|
||||
you may at your option offer warranty protection in exchange for a fee.
|
||||
|
||||
2. You may modify your copy or copies of the Program or any portion
|
||||
of it, thus forming a work based on the Program, and copy and
|
||||
distribute such modifications or work under the terms of Section 1
|
||||
above, provided that you also meet all of these conditions:
|
||||
|
||||
a) You must cause the modified files to carry prominent notices
|
||||
stating that you changed the files and the date of any change.
|
||||
|
||||
b) You must cause any work that you distribute or publish, that in
|
||||
whole or in part contains or is derived from the Program or any
|
||||
part thereof, to be licensed as a whole at no charge to all third
|
||||
parties under the terms of this License.
|
||||
|
||||
c) If the modified program normally reads commands interactively
|
||||
when run, you must cause it, when started running for such
|
||||
interactive use in the most ordinary way, to print or display an
|
||||
announcement including an appropriate copyright notice and a
|
||||
notice that there is no warranty (or else, saying that you provide
|
||||
a warranty) and that users may redistribute the program under
|
||||
these conditions, and telling the user how to view a copy of this
|
||||
License. (Exception: if the Program itself is interactive but
|
||||
does not normally print such an announcement, your work based on
|
||||
the Program is not required to print an announcement.)
|
||||
|
||||
These requirements apply to the modified work as a whole. If
|
||||
identifiable sections of that work are not derived from the Program,
|
||||
and can be reasonably considered independent and separate works in
|
||||
themselves, then this License, and its terms, do not apply to those
|
||||
sections when you distribute them as separate works. But when you
|
||||
distribute the same sections as part of a whole which is a work based
|
||||
on the Program, the distribution of the whole must be on the terms of
|
||||
this License, whose permissions for other licensees extend to the
|
||||
entire whole, and thus to each and every part regardless of who wrote it.
|
||||
|
||||
Thus, it is not the intent of this section to claim rights or contest
|
||||
your rights to work written entirely by you; rather, the intent is to
|
||||
exercise the right to control the distribution of derivative or
|
||||
collective works based on the Program.
|
||||
|
||||
In addition, mere aggregation of another work not based on the Program
|
||||
with the Program (or with a work based on the Program) on a volume of
|
||||
a storage or distribution medium does not bring the other work under
|
||||
the scope of this License.
|
||||
|
||||
3. You may copy and distribute the Program (or a work based on it,
|
||||
under Section 2) in object code or executable form under the terms of
|
||||
Sections 1 and 2 above provided that you also do one of the following:
|
||||
|
||||
a) Accompany it with the complete corresponding machine-readable
|
||||
source code, which must be distributed under the terms of Sections
|
||||
1 and 2 above on a medium customarily used for software interchange; or,
|
||||
|
||||
b) Accompany it with a written offer, valid for at least three
|
||||
years, to give any third party, for a charge no more than your
|
||||
cost of physically performing source distribution, a complete
|
||||
machine-readable copy of the corresponding source code, to be
|
||||
distributed under the terms of Sections 1 and 2 above on a medium
|
||||
customarily used for software interchange; or,
|
||||
|
||||
c) Accompany it with the information you received as to the offer
|
||||
to distribute corresponding source code. (This alternative is
|
||||
allowed only for noncommercial distribution and only if you
|
||||
received the program in object code or executable form with such
|
||||
an offer, in accord with Subsection b above.)
|
||||
|
||||
The source code for a work means the preferred form of the work for
|
||||
making modifications to it. For an executable work, complete source
|
||||
code means all the source code for all modules it contains, plus any
|
||||
associated interface definition files, plus the scripts used to
|
||||
control compilation and installation of the executable. However, as a
|
||||
special exception, the source code distributed need not include
|
||||
anything that is normally distributed (in either source or binary
|
||||
form) with the major components (compiler, kernel, and so on) of the
|
||||
operating system on which the executable runs, unless that component
|
||||
itself accompanies the executable.
|
||||
|
||||
If distribution of executable or object code is made by offering
|
||||
access to copy from a designated place, then offering equivalent
|
||||
access to copy the source code from the same place counts as
|
||||
distribution of the source code, even though third parties are not
|
||||
compelled to copy the source along with the object code.
|
||||
|
||||
4. You may not copy, modify, sublicense, or distribute the Program
|
||||
except as expressly provided under this License. Any attempt
|
||||
otherwise to copy, modify, sublicense or distribute the Program is
|
||||
void, and will automatically terminate your rights under this License.
|
||||
However, parties who have received copies, or rights, from you under
|
||||
this License will not have their licenses terminated so long as such
|
||||
parties remain in full compliance.
|
||||
|
||||
5. You are not required to accept this License, since you have not
|
||||
signed it. However, nothing else grants you permission to modify or
|
||||
distribute the Program or its derivative works. These actions are
|
||||
prohibited by law if you do not accept this License. Therefore, by
|
||||
modifying or distributing the Program (or any work based on the
|
||||
Program), you indicate your acceptance of this License to do so, and
|
||||
all its terms and conditions for copying, distributing or modifying
|
||||
the Program or works based on it.
|
||||
|
||||
6. Each time you redistribute the Program (or any work based on the
|
||||
Program), the recipient automatically receives a license from the
|
||||
original licensor to copy, distribute or modify the Program subject to
|
||||
these terms and conditions. You may not impose any further
|
||||
restrictions on the recipients' exercise of the rights granted herein.
|
||||
You are not responsible for enforcing compliance by third parties to
|
||||
this License.
|
||||
|
||||
7. If, as a consequence of a court judgment or allegation of patent
|
||||
infringement or for any other reason (not limited to patent issues),
|
||||
conditions are imposed on you (whether by court order, agreement or
|
||||
otherwise) that contradict the conditions of this License, they do not
|
||||
excuse you from the conditions of this License. If you cannot
|
||||
distribute so as to satisfy simultaneously your obligations under this
|
||||
License and any other pertinent obligations, then as a consequence you
|
||||
may not distribute the Program at all. For example, if a patent
|
||||
license would not permit royalty-free redistribution of the Program by
|
||||
all those who receive copies directly or indirectly through you, then
|
||||
the only way you could satisfy both it and this License would be to
|
||||
refrain entirely from distribution of the Program.
|
||||
|
||||
If any portion of this section is held invalid or unenforceable under
|
||||
any particular circumstance, the balance of the section is intended to
|
||||
apply and the section as a whole is intended to apply in other
|
||||
circumstances.
|
||||
|
||||
It is not the purpose of this section to induce you to infringe any
|
||||
patents or other property right claims or to contest validity of any
|
||||
such claims; this section has the sole purpose of protecting the
|
||||
integrity of the free software distribution system, which is
|
||||
implemented by public license practices. Many people have made
|
||||
generous contributions to the wide range of software distributed
|
||||
through that system in reliance on consistent application of that
|
||||
system; it is up to the author/donor to decide if he or she is willing
|
||||
to distribute software through any other system and a licensee cannot
|
||||
impose that choice.
|
||||
|
||||
This section is intended to make thoroughly clear what is believed to
|
||||
be a consequence of the rest of this License.
|
||||
|
||||
8. If the distribution and/or use of the Program is restricted in
|
||||
certain countries either by patents or by copyrighted interfaces, the
|
||||
original copyright holder who places the Program under this License
|
||||
may add an explicit geographical distribution limitation excluding
|
||||
those countries, so that distribution is permitted only in or among
|
||||
countries not thus excluded. In such case, this License incorporates
|
||||
the limitation as if written in the body of this License.
|
||||
|
||||
9. The Free Software Foundation may publish revised and/or new versions
|
||||
of the General Public License from time to time. Such new versions will
|
||||
be similar in spirit to the present version, but may differ in detail to
|
||||
address new problems or concerns.
|
||||
|
||||
Each version is given a distinguishing version number. If the Program
|
||||
specifies a version number of this License which applies to it and "any
|
||||
later version", you have the option of following the terms and conditions
|
||||
either of that version or of any later version published by the Free
|
||||
Software Foundation. If the Program does not specify a version number of
|
||||
this License, you may choose any version ever published by the Free Software
|
||||
Foundation.
|
||||
|
||||
10. If you wish to incorporate parts of the Program into other free
|
||||
programs whose distribution conditions are different, write to the author
|
||||
to ask for permission. For software which is copyrighted by the Free
|
||||
Software Foundation, write to the Free Software Foundation; we sometimes
|
||||
make exceptions for this. Our decision will be guided by the two goals
|
||||
of preserving the free status of all derivatives of our free software and
|
||||
of promoting the sharing and reuse of software generally.
|
||||
|
||||
NO WARRANTY
|
||||
|
||||
11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
|
||||
FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
|
||||
OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
|
||||
PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
|
||||
OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
||||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
|
||||
TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE
|
||||
PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
|
||||
REPAIR OR CORRECTION.
|
||||
|
||||
12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
|
||||
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
|
||||
REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
|
||||
INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
|
||||
OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
|
||||
TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
|
||||
YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
|
||||
PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
|
||||
POSSIBILITY OF SUCH DAMAGES.
|
||||
|
||||
END OF TERMS AND CONDITIONS
|
||||
|
||||
How to Apply These Terms to Your New Programs
|
||||
|
||||
If you develop a new program, and you want it to be of the greatest
|
||||
possible use to the public, the best way to achieve this is to make it
|
||||
free software which everyone can redistribute and change under these terms.
|
||||
|
||||
To do so, attach the following notices to the program. It is safest
|
||||
to attach them to the start of each source file to most effectively
|
||||
convey the exclusion of warranty; and each file should have at least
|
||||
the "copyright" line and a pointer to where the full notice is found.
|
||||
|
||||
<one line to give the program's name and a brief idea of what it does.>
|
||||
Copyright (C) <year> <name of author>
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation; either version 2 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License along
|
||||
with this program; if not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
||||
|
||||
Also add information on how to contact you by electronic and paper mail.
|
||||
|
||||
If the program is interactive, make it output a short notice like this
|
||||
when it starts in an interactive mode:
|
||||
|
||||
Gnomovision version 69, Copyright (C) year name of author
|
||||
Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
|
||||
This is free software, and you are welcome to redistribute it
|
||||
under certain conditions; type `show c' for details.
|
||||
|
||||
The hypothetical commands `show w' and `show c' should show the appropriate
|
||||
parts of the General Public License. Of course, the commands you use may
|
||||
be called something other than `show w' and `show c'; they could even be
|
||||
mouse-clicks or menu items--whatever suits your program.
|
||||
|
||||
You should also get your employer (if you work as a programmer) or your
|
||||
school, if any, to sign a "copyright disclaimer" for the program, if
|
||||
necessary. Here is a sample; alter the names:
|
||||
|
||||
Yoyodyne, Inc., hereby disclaims all copyright interest in the program
|
||||
`Gnomovision' (which makes passes at compilers) written by James Hacker.
|
||||
|
||||
<signature of Ty Coon>, 1 April 1989
|
||||
Ty Coon, President of Vice
|
||||
|
||||
This General Public License does not permit incorporating your program into
|
||||
proprietary programs. If your program is a subroutine library, you may
|
||||
consider it more useful to permit linking proprietary applications with the
|
||||
library. If this is what you want to do, use the GNU Lesser General
|
||||
Public License instead of this License.
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
SOFTWARE.
|
||||
|
||||
110
Makefile
110
Makefile
@@ -1,9 +1,7 @@
|
||||
CC ?= gcc
|
||||
CXX=gcc
|
||||
|
||||
CFLAGS+=-Wall -Wextra -pedantic
|
||||
SANITY_FLAGS=-Wfloat-equal -Wshadow -Wpointer-arith -Wstrict-prototypes
|
||||
|
||||
PREFIX ?= /usr
|
||||
CXXFLAGS=-Wall -Wextra -Werror -pedantic -fstack-protector-all -pedantic -std=c99
|
||||
SANITY_FLAGS=-Wfloat-equal -Wshadow -Wpointer-arith
|
||||
|
||||
SRC_COMMON=src/common/
|
||||
|
||||
@@ -11,118 +9,48 @@ COMMON_SRC = $(SRC_COMMON)main.c $(SRC_COMMON)cpu.c $(SRC_COMMON)udev.c $(SRC_CO
|
||||
COMMON_HDR = $(SRC_COMMON)ascii.h $(SRC_COMMON)cpu.h $(SRC_COMMON)udev.h $(SRC_COMMON)printer.h $(SRC_COMMON)args.h $(SRC_COMMON)global.h
|
||||
|
||||
ifneq ($(OS),Windows_NT)
|
||||
GIT_VERSION := "$(shell git describe --abbrev=4 --dirty --always --tags)"
|
||||
arch := $(shell uname -m)
|
||||
os := $(shell uname -s)
|
||||
|
||||
ifeq ($(os), Linux)
|
||||
COMMON_SRC += $(SRC_COMMON)freq.c
|
||||
COMMON_HDR += $(SRC_COMMON)freq.h
|
||||
endif
|
||||
|
||||
ifeq ($(arch), $(filter $(arch), x86_64 amd64 i386 i486 i586 i686))
|
||||
ifeq ($(arch), x86_64)
|
||||
SRC_DIR=src/x86/
|
||||
SOURCE += $(COMMON_SRC) $(SRC_DIR)cpuid.c $(SRC_DIR)apic.c $(SRC_DIR)cpuid_asm.c $(SRC_DIR)uarch.c
|
||||
HEADERS += $(COMMON_HDR) $(SRC_DIR)cpuid.h $(SRC_DIR)apic.h $(SRC_DIR)cpuid_asm.h $(SRC_DIR)uarch.h $(SRC_DIR)freq/freq.h
|
||||
|
||||
ifeq ($(os), Linux)
|
||||
SOURCE += $(SRC_DIR)freq/freq.c freq_nov.o freq_avx.o freq_avx512.o
|
||||
HEADERS += $(SRC_DIR)freq/freq.h
|
||||
CFLAGS += -pthread
|
||||
endif
|
||||
ifeq ($(os), FreeBSD)
|
||||
SOURCE += $(SRC_COMMON)sysctl.c
|
||||
HEADERS += $(SRC_COMMON)sysctl.h
|
||||
endif
|
||||
CFLAGS += -DARCH_X86 -std=c99 -fstack-protector-all
|
||||
else ifeq ($(arch), $(filter $(arch), ppc64le ppc64 ppcle ppc))
|
||||
SRC_DIR=src/ppc/
|
||||
SOURCE += $(COMMON_SRC) $(SRC_DIR)ppc.c $(SRC_DIR)uarch.c $(SRC_DIR)udev.c
|
||||
HEADERS += $(COMMON_HDR) $(SRC_DIR)ppc.h $(SRC_DIR)uarch.h $(SRC_DIR)udev.c
|
||||
CFLAGS += -DARCH_PPC -std=gnu99 -fstack-protector-all -Wno-language-extension-token
|
||||
else ifeq ($(arch), $(filter $(arch), arm aarch64_be aarch64 arm64 armv8b armv8l armv7l armv6l))
|
||||
SRC_DIR=src/arm/
|
||||
SOURCE += $(COMMON_SRC) $(SRC_DIR)midr.c $(SRC_DIR)uarch.c $(SRC_COMMON)soc.c $(SRC_DIR)soc.c $(SRC_COMMON)pci.c $(SRC_DIR)udev.c sve.o
|
||||
HEADERS += $(COMMON_HDR) $(SRC_DIR)midr.h $(SRC_DIR)uarch.h $(SRC_COMMON)soc.h $(SRC_DIR)soc.h $(SRC_COMMON)pci.h $(SRC_DIR)udev.c $(SRC_DIR)socs.h
|
||||
CFLAGS += -DARCH_ARM -Wno-unused-parameter -std=c99 -fstack-protector-all
|
||||
|
||||
# Check if the compiler supports -march=armv8-a+sve. We will use it (if supported) to compile SVE detection code later
|
||||
is_sve_flag_supported := $(shell $(CC) -march=armv8-a+sve -c $(SRC_DIR)sve.c -o sve_test.o 2> /dev/null && echo 'yes'; rm -f sve_test.o)
|
||||
ifeq ($(is_sve_flag_supported), yes)
|
||||
SVE_FLAGS += -march=armv8-a+sve
|
||||
endif
|
||||
|
||||
ifeq ($(os), Darwin)
|
||||
SOURCE += $(SRC_COMMON)sysctl.c
|
||||
HEADERS += $(SRC_COMMON)sysctl.h
|
||||
endif
|
||||
else ifeq ($(arch), $(filter $(arch), riscv64 riscv32))
|
||||
SRC_DIR=src/riscv/
|
||||
SOURCE += $(COMMON_SRC) $(SRC_DIR)riscv.c $(SRC_DIR)uarch.c $(SRC_COMMON)soc.c $(SRC_DIR)soc.c $(SRC_DIR)udev.c
|
||||
HEADERS += $(COMMON_HDR) $(SRC_DIR)riscv.h $(SRC_DIR)uarch.h $(SRC_COMMON)soc.h $(SRC_DIR)soc.h $(SRC_DIR)udev.h $(SRC_DIR)socs.h
|
||||
CFLAGS += -DARCH_RISCV -Wno-unused-parameter -std=c99 -fstack-protector-all
|
||||
HEADERS += $(COMMON_HDR) $(SRC_DIR)cpuid.h $(SRC_DIR)apic.h $(SRC_DIR)cpuid_asm.h $(SRC_DIR)uarch.h
|
||||
CXXFLAGS += -DARCH_X86
|
||||
else
|
||||
# Error lines should not be tabulated because Makefile complains about it
|
||||
$(warning Unsupported arch detected: $(arch). See https://github.com/Dr-Noob/cpufetch#1-support)
|
||||
$(warning If your architecture is supported but the compilation fails, please open an issue in https://github.com/Dr-Noob/cpufetch/issues)
|
||||
$(error Aborting compilation)
|
||||
SRC_DIR=src/arm/
|
||||
SOURCE += $(COMMON_SRC) $(SRC_DIR)midr.c $(SRC_DIR)uarch.c $(SRC_DIR)soc.c $(SRC_DIR)udev.c
|
||||
HEADERS += $(COMMON_HDR) $(SRC_DIR)midr.h $(SRC_DIR)uarch.h $(SRC_DIR)soc.h $(SRC_DIR)udev.c $(SRC_DIR)socs.h
|
||||
CXXFLAGS += -DARCH_ARM -Wno-unused-parameter
|
||||
endif
|
||||
|
||||
OUTPUT=cpufetch
|
||||
else
|
||||
# Assume x86_64
|
||||
GIT_VERSION := ""
|
||||
SRC_DIR=src/x86/
|
||||
SOURCE += $(COMMON_SRC) $(SRC_DIR)cpuid.c $(SRC_DIR)apic.c $(SRC_DIR)cpuid_asm.c $(SRC_DIR)uarch.c
|
||||
HEADERS += $(COMMON_HDR) $(SRC_DIR)cpuid.h $(SRC_DIR)apic.h $(SRC_DIR)cpuid_asm.h $(SRC_DIR)uarch.h
|
||||
CFLAGS += -DARCH_X86 -std=c99
|
||||
CXXFLAGS += -DARCH_X86
|
||||
SANITY_FLAGS += -Wno-pedantic-ms-format
|
||||
OUTPUT=cpufetch.exe
|
||||
endif
|
||||
|
||||
all: CFLAGS += -O2
|
||||
all: $(OUTPUT)
|
||||
|
||||
debug: CFLAGS += -g -O0
|
||||
debug: CXXFLAGS += -g -O0
|
||||
debug: $(OUTPUT)
|
||||
|
||||
static: CFLAGS += -static -O2
|
||||
static: $(OUTPUT)
|
||||
|
||||
strict: CFLAGS += -O2 -Werror -fsanitize=undefined -D_FORTIFY_SOURCE=2
|
||||
strict: $(OUTPUT)
|
||||
|
||||
freq_nov.o: Makefile $(SRC_DIR)freq/freq_nov.c $(SRC_DIR)freq/freq_nov.h $(SRC_DIR)freq/freq.h
|
||||
$(CC) $(CFLAGS) $(SANITY_FLAGS) -c -pthread $(SRC_DIR)freq/freq_nov.c -o $@
|
||||
|
||||
freq_avx.o: Makefile $(SRC_DIR)freq/freq_avx.c $(SRC_DIR)freq/freq_avx.h $(SRC_DIR)freq/freq.h
|
||||
$(CC) $(CFLAGS) $(SANITY_FLAGS) -c -mavx -pthread $(SRC_DIR)freq/freq_avx.c -o $@
|
||||
|
||||
freq_avx512.o: Makefile $(SRC_DIR)freq/freq_avx512.c $(SRC_DIR)freq/freq_avx512.h $(SRC_DIR)freq/freq.h
|
||||
$(CC) $(CFLAGS) $(SANITY_FLAGS) -c -mavx512f -pthread $(SRC_DIR)freq/freq_avx512.c -o $@
|
||||
|
||||
sve.o: Makefile $(SRC_DIR)sve.c $(SRC_DIR)sve.h
|
||||
$(CC) $(CFLAGS) $(SANITY_FLAGS) $(SVE_FLAGS) -c $(SRC_DIR)sve.c -o $@
|
||||
release: CXXFLAGS += -static -O3
|
||||
release: $(OUTPUT)
|
||||
|
||||
$(OUTPUT): Makefile $(SOURCE) $(HEADERS)
|
||||
ifeq ($(GIT_VERSION),"")
|
||||
$(CC) $(CFLAGS) $(SANITY_FLAGS) $(SOURCE) -o $(OUTPUT)
|
||||
else
|
||||
$(CC) $(CFLAGS) $(SANITY_FLAGS) -DGIT_FULL_VERSION=\"$(GIT_VERSION)\" $(SOURCE) -o $(OUTPUT)
|
||||
endif
|
||||
$(CXX) $(CXXFLAGS) $(SANITY_FLAGS) $(SOURCE) -o $(OUTPUT)
|
||||
|
||||
run: $(OUTPUT)
|
||||
./$(OUTPUT)
|
||||
|
||||
clean:
|
||||
@rm -f $(OUTPUT) *.o
|
||||
@rm $(OUTPUT)
|
||||
|
||||
install: $(OUTPUT)
|
||||
install -Dm755 "cpufetch" "$(DESTDIR)$(PREFIX)/bin/cpufetch"
|
||||
install -Dm644 "LICENSE" "$(DESTDIR)$(PREFIX)/share/licenses/cpufetch-git/LICENSE"
|
||||
install -Dm644 "cpufetch.1" "$(DESTDIR)$(PREFIX)/share/man/man1/cpufetch.1"
|
||||
|
||||
uninstall:
|
||||
rm -f "$(DESTDIR)$(PREFIX)/bin/cpufetch"
|
||||
rm -f "$(DESTDIR)$(PREFIX)/share/licenses/cpufetch-git/LICENSE"
|
||||
rm -f "$(DESTDIR)$(PREFIX)/share/man/man1/cpufetch.1"
|
||||
install -Dm755 "cpufetch" "/usr/bin/cpufetch"
|
||||
install -Dm644 "LICENSE" "/usr/share/licenses/cpufetch-git/LICENSE"
|
||||
install -Dm644 "cpufetch.8" "/usr/share/man/man8/cpufetch.8.gz"
|
||||
|
||||
198
README.md
198
README.md
@@ -1,87 +1,36 @@
|
||||
<p align="center"><img width=50% src="./pictures/cpufetch.png"></p>
|
||||
# cpufetch
|
||||
|
||||
<h4 align="center">Simple yet fancy CPU architecture fetching tool</h4>
|
||||
Simplistic yet fancy CPU architecture fetching tool
|
||||
|
||||
|
||||
<p align="center"> </p>
|
||||
### Platforms
|
||||
cpufetch currently supports x86_64 CPUs (both Intel and AMD) and ARM.
|
||||
|
||||
<div align="center">
|
||||
<img height="22px" src="https://img.shields.io/github/v/tag/Dr-Noob/cpufetch?label=cpufetch&style=flat-square">
|
||||
<a href="https://github.com/Dr-Noob/cpufetch/stargazers">
|
||||
<img height="22px" src="https://img.shields.io/github/stars/Dr-Noob/cpufetch?color=4CC61F&style=flat-square">
|
||||
</a>
|
||||
<a href="https://github.com/Dr-Noob/cpufetch/issues">
|
||||
<img height="22px" src="https://img.shields.io/github/issues/Dr-Noob/cpufetch?style=flat-square">
|
||||
</a>
|
||||
<a href="https://github.com/Dr-Noob/cpufetch/blob/master/README.md#1-support">
|
||||
<img height="22px" src="pictures/os-shield.jpg">
|
||||
</a>
|
||||
<a href="https://github.com/Dr-Noob/cpufetch/blob/master/LICENSE">
|
||||
<img height="22px" src="https://img.shields.io/github/license/Dr-Noob/cpufetch?color=orange&style=flat-square">
|
||||
</a>
|
||||
</div>
|
||||
| Platform | x86_64 | ARM | Notes |
|
||||
|:---------:|:------------------------:|:-------------------:|:-----------------:|
|
||||
| Linux | :heavy_check_mark: | :heavy_check_mark: | Prefered platform. <br> Experimental ARM support |
|
||||
| Windows | :heavy_check_mark: | :x: | Some information may be missing. <br> Colors will be used if supported |
|
||||
| Android | :heavy_exclamation_mark: | :heavy_check_mark: | Experimental ARM support |
|
||||
| macOS | :heavy_check_mark: | :x: | Some information may be missing |
|
||||
|
||||
<p align="center"> </p>
|
||||
|
||||
<p align="center">
|
||||
cpufetch is a command-line tool written in C that displays the CPU information in a clean and beautiful way
|
||||
</p>
|
||||
|
||||
<p align="center">
|
||||
<img width=80% src="./pictures/examples.gif">
|
||||
</p>
|
||||
|
||||
# Table of contents
|
||||
<!-- UPDATE with: doctoc --notitle README.md -->
|
||||
<!-- START doctoc generated TOC please keep comment here to allow auto update -->
|
||||
<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->
|
||||
| Emoji | Meaning |
|
||||
|:-----------------------:|:-------------:|
|
||||
|:heavy_check_mark: | Supported |
|
||||
|:x: | Not supported |
|
||||
|:heavy_exclamation_mark: | Not tested |
|
||||
|
||||
|
||||
- [1. Support](#1-support)
|
||||
- [2. Installation](#2-installation)
|
||||
- [2.1 Installing from a package](#21-installing-from-a-package)
|
||||
- [2.2 Building from source](#22-building-from-source)
|
||||
- [2.3 Android](#23-android)
|
||||
- [3. Examples](#3-examples)
|
||||
- [3.1 x86_64](#31-x86_64)
|
||||
- [3.2 ARM](#32-arm)
|
||||
- [3.3 PowerPC](#33-powerpc)
|
||||
- [3.4 RISC-V](#34-risc-v)
|
||||
- [4. Colors](#4-colors)
|
||||
- [4.1 Specifying a name](#41-specifying-a-name)
|
||||
- [4.2 Specifying the colors in RGB format](#42-specifying-the-colors-in-rgb-format)
|
||||
- [5. Implementation](#5-implementation)
|
||||
- [6. Bugs or improvements](#6-bugs-or-improvements)
|
||||
- [6.1 Unknown microarchitecture error](#61-unknown-microarchitecture-error)
|
||||
- [6.2 Other situations](#62-other-situations)
|
||||
- [7. Acknowledgements](#7-acknowledgements)
|
||||
- [8. cpufetch for GPUs (gpufetch)](#8-cpufetch-for-gpus-gpufetch)
|
||||
### Usage and installation
|
||||
#### Linux
|
||||
There is a cpufetch package available in Arch Linux ([cpufetch-git](https://aur.archlinux.org/packages/cpufetch-git)).
|
||||
|
||||
<!-- END doctoc generated TOC please keep comment here to allow auto update -->
|
||||
If you are in another distro, you can build `cpufetch` from source (see below)
|
||||
|
||||
## 1. Support
|
||||
#### Windows
|
||||
In the [releases](https://github.com/Dr-Noob/cpufetch/releases) section you will find some cpufetch executables compiled for Windows. Just download and run it from Windows CMD.
|
||||
|
||||
| OS | x86_64 / x86 | ARM | RISC-V | PowerPC |
|
||||
|:-----------:|:------------------:|:------------------:|:------------------:|:------------------:|
|
||||
| GNU / Linux | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: |
|
||||
| Windows | :heavy_check_mark: | :x: | :x: | :x: |
|
||||
| Android | :heavy_check_mark: | :heavy_check_mark: | :x: | :x: |
|
||||
| macOS | :heavy_check_mark: | :heavy_check_mark: | :x: | :heavy_check_mark: |
|
||||
| FreeBSD | :heavy_check_mark: | :x: | :x: | :x: |
|
||||
|
||||
**NOTES:**
|
||||
- Colors will be used in Windows only if the terminal supports it.
|
||||
- Support in macOS ARM is limited to Apple chips only
|
||||
|
||||
## 2. Installation
|
||||
### 2.1 Installing from a package
|
||||
Choose the right package for your operating system:
|
||||
|
||||
[](https://repology.org/project/cpufetch/versions)
|
||||
|
||||
If there is no available package for your OS, you can download the cpufetch binary from [the releases page](https://github.com/Dr-Noob/cpufetch/releases), or [build cpufetch from source](#22-building-from-source-linuxwindowsmacos) (see below).
|
||||
|
||||
### 2.2 Building from source
|
||||
You will need a C compiler (e.g, `gcc`) and `make` to compile `cpufetch`. Just clone the repo and run `make`:
|
||||
#### Building from source
|
||||
Just clone the repo and use `make` to compile it
|
||||
|
||||
```
|
||||
git clone https://github.com/Dr-Noob/cpufetch
|
||||
@@ -90,98 +39,41 @@ make
|
||||
./cpufetch
|
||||
```
|
||||
|
||||
### 2.3 Android
|
||||
1. Install `termux` app (terminal emulator)
|
||||
2. Run `pkg install -y git make clang` inside termux.
|
||||
3. Build from source normally:
|
||||
- git clone https://github.com/Dr-Noob/cpufetch
|
||||
- cd cpufetch
|
||||
- make
|
||||
- ./cpufetch
|
||||
The Makefile is designed to work on both Linux and Windows.
|
||||
|
||||
## 3. Examples
|
||||
### 3.1 x86_64
|
||||
### Examples
|
||||
Here are more examples of how `cpufetch` looks on different CPUs.
|
||||
|
||||
<p align="center"><img width=90% src="pictures/epyc.png"></p>
|
||||
<p align="center">AMD EPYC HPC server</p>
|
||||
<p align="center"><img width=90% src="pictures/cascade_lake.jpg"></p>
|
||||
<p align="center">Intel Xeon HPC server</p>
|
||||
##### x86_64 CPUs
|
||||
|
||||
### 3.2 ARM
|
||||
|
||||
|
||||
<p align="center">
|
||||
<img width=45% src="pictures/exynos.jpg">
|
||||
|
||||
<img width=45% src="pictures/snapd.png">
|
||||
</p>
|
||||
<p align="center">Samsung Galaxy S8 (left) Xiaomi Redmi Note 7 (right)</p>
|
||||
|
||||
|
||||
### 3.3 PowerPC
|
||||
##### ARM CPUs
|
||||
|
||||
<p align="center"><img width=90% src="pictures/ibm.png"></p>
|
||||
<p align="center">Talos II</p>
|
||||
|
||||
|
||||
## 3.4 RISC-V
|
||||
|
||||
|
||||
<p align="center"><img width=80% src="pictures/starfive.png"></p>
|
||||
<p align="center">StarFive VisionFive 2</p>
|
||||
|
||||
## 4. Colors
|
||||
By default, `cpufetch` will print the CPU logo with the system colorscheme. However, you can set a custom color scheme in two different ways:
|
||||
|
||||
### 4.1 Specifying a name
|
||||
|
||||
By specifying a name, cpufetch will use the specific colors of each manufacture. Valid values are:
|
||||
|
||||
- intel
|
||||
- intel-new
|
||||
- amd
|
||||
- ibm
|
||||
- arm
|
||||
### Colors and style
|
||||
By default, `cpufetch` will print the CPU art with the system colorscheme. However, you can always set a custom color scheme, either
|
||||
specifying Intel or AMD, or specifying the colors in RGB format:
|
||||
|
||||
```
|
||||
./cpufetch --color intel (default color for Intel)
|
||||
./cpufetch --color amd (default color for AND)
|
||||
./cpufetch --color 239,90,45:210,200,200:100,200,45:0,200,200 (example)
|
||||
```
|
||||
|
||||
### 4.2 Specifying the colors in RGB format
|
||||
In the case of setting the colors using RGB, 4 colors must be given in with the format: ``[R,G,B:R,G,B:R,G,B:R,G,B]``. These colors correspond to CPU art color (2 colors) and for the text colors (following 2). Thus, you can customize all the colors.
|
||||
|
||||
5 colors must be given in RGB with the format: ``[R,G,B:R,G,B:R,G,B:R,G,B:R,G,B]``. These colors correspond to the CPU logo color (first 3 colors) and for the text colors (following 2).
|
||||
### Implementation
|
||||
|
||||
```
|
||||
./cpufetch --color 239,90,45:210,200,200:0,0,0:100,200,45:0,200,200
|
||||
```
|
||||
See [cpufetch programming documentation](https://github.com/Dr-Noob/cpufetch/blob/master/doc/README.md).
|
||||
|
||||
## 5. Implementation
|
||||
See [cpufetch programming documentation](https://github.com/Dr-Noob/cpufetch/tree/master/doc).
|
||||
### Bugs or improvements
|
||||
There are many open issues in github (see [issues](https://github.com/Dr-Noob/cpufetch/issues)). Feel free to open a new one report an issue or propose any improvement in `cpufetch`
|
||||
|
||||
## 6. Bugs or improvements
|
||||
### 6.1 Unknown microarchitecture error
|
||||
If you get the `Unknown microarchitecture detected` error when running cpufetch, it might be caused by two possible reasons:
|
||||
|
||||
1. You are running an old release of cpufetch (most likely)
|
||||
2. Your microarchitecture is not yet supported
|
||||
|
||||
Download and compile the latest version (see https://github.com/Dr-Noob/cpufetch#22-building-from-source for instructions)
|
||||
and verify if the error persists.
|
||||
|
||||
* __If the error dissapears__: It means that this is the first situation. In this case, just use the
|
||||
latest version of cpufetch which already has support for your hardware.
|
||||
* __If the error does not dissapear__: It means that this is the
|
||||
second situation. In this case, please create a new issue with the error message and the output of 'cpufetch --debug' on https://github.com/Dr-Noob/cpufetch/issues
|
||||
|
||||
### 6.2 Other situations
|
||||
See [cpufetch contributing guidelines](https://github.com/Dr-Noob/cpufetch/blob/master/CONTRIBUTING.md).
|
||||
|
||||
## 7. Acknowledgements
|
||||
Thanks to the fellow contributors and interested people in the project. Special thanks to:
|
||||
- [Gonzalocl](https://github.com/Gonzalocl) and [OdnetninI](https://github.com/OdnetninI): Tested cpufetch in the earlier versions of the project in many different CPUs.
|
||||
- [Kyngo](https://github.com/Kyngo): Tested cpufetch in the Apple M1 CPU.
|
||||
- [avollmerhaus](https://github.com/avollmerhaus): Helped with PowerPC port giving ssh access to a PowerPC machine.
|
||||
- [bbonev](https://github.com/bbonev) and [stephan-cr](https://github.com/stephan-cr): Reviewed the source code.
|
||||
- [mdoksa76](https://github.com/mdoksa76) and [exkc](https://github.com/exkc): Excellent ideas and feedback for supporting Allwinner SoCs.
|
||||
- [Sakura286](https://github.com/Sakura286), [exkc](https://github.com/exkc) and [Patola](https://github.com/Patola): Helped with RISC-V port with ssh access, ideas, testing, etc.
|
||||
- [ThomasKaiser](https://github.com/ThomasKaiser): Very valuable feedback on improving ARM SoC detection (Apple, Allwinner, Rockchip).
|
||||
- [zerkerX](https://github.com/zerkerX): Helped with feedback for supporting old (e.g., Pentium III) Intel CPUs.
|
||||
|
||||
## 8. cpufetch for GPUs (gpufetch)
|
||||
See [gpufetch](https://github.com/Dr-Noob/gpufetch) project!
|
||||
### Testing
|
||||
I would like to thank [Gonzalocl](https://github.com/Gonzalocl) and [OdnetninI](https://github.com/OdnetninI) for their help, running `cpufetch` in many different CPUs they have access to, which makes it easier to debug and check the correctness of `cpufetch`.
|
||||
|
||||
91
cpufetch.1
91
cpufetch.1
@@ -1,91 +0,0 @@
|
||||
.\" DO NOT MODIFY THIS FILE! It was generated by help2man 1.48.3. It was also manually adapted to look correctly
|
||||
.\" help2man -N -n "Simple yet fancy CPU architecture fetching tool" ./cpufetch > cpufetch.1
|
||||
.TH CPUFETCH "1" "September 2021" "cpufetch v1.00 (Linux x86_64 build)" "User Commands"
|
||||
.SH NAME
|
||||
cpufetch \- Simple yet fancy CPU architecture fetching tool
|
||||
.SH SYNOPSIS
|
||||
.B cpufetch
|
||||
[\fI\,OPTION\/\fR]...
|
||||
.SH DESCRIPTION
|
||||
cpufetch is a command-line tool written in C that displays the CPU information in a clean and beautiful way
|
||||
.SH OPTIONS
|
||||
.TP
|
||||
\fB\-c\fR, \fB\-\-color\fR
|
||||
Set the color scheme (by default, cpufetch uses the system color scheme)
|
||||
.TP
|
||||
\fB\-s\fR, \fB\-\-style\fR
|
||||
Set the style of CPU logo
|
||||
.TP
|
||||
\fB\-d\fR, \fB\-\-debug\fR
|
||||
Print CPU model and cpuid levels (debug purposes)
|
||||
.TP
|
||||
\fB\-\-logo\-short\fR
|
||||
Show the short version of the logo
|
||||
.TP
|
||||
\fB\-\-logo\-long\fR
|
||||
Show the long version of the logo
|
||||
.TP
|
||||
\fB\-v\fR, \fB\-\-verbose\fR
|
||||
Print extra information (if available) about how cpufetch tried fetching information
|
||||
.TP
|
||||
\fB\-\-logo\-intel\-old\fR
|
||||
Show the old Intel logo
|
||||
.TP
|
||||
\fB\-\-logo\-intel\-new\fR
|
||||
Show the new Intel logo
|
||||
.TP
|
||||
\fB\-F\fR, \fB\-\-full\-cpu\-name\fR
|
||||
Show the full CPU name (do not abbreviate it)
|
||||
.TP
|
||||
\fB\-r\fR, \fB\-\-raw\fR
|
||||
Print raw cpuid data (debug purposes)
|
||||
.TP
|
||||
\fB\-h\fR, \fB\-\-help\fR
|
||||
Print this help and exit
|
||||
.TP
|
||||
\fB\-V\fR, \fB\-\-version\fR
|
||||
Print cpufetch version and exit
|
||||
.SH COLORS
|
||||
.TP
|
||||
* "intel":
|
||||
Use Intel default color scheme
|
||||
.TP
|
||||
* "amd":
|
||||
Use AMD default color scheme
|
||||
.TP
|
||||
* "ibm",
|
||||
Use IBM default color scheme
|
||||
.TP
|
||||
* "arm":
|
||||
Use ARM default color scheme
|
||||
.TP
|
||||
* custom:
|
||||
If the argument of \fB\-\-color\fR does not match any of the previous strings, a custom scheme can be specified. 5 colors must be given in RGB with the format: R,G,B:R,G,B:...The first 3 colors are the CPU art color and the next 2 colors are the text colors
|
||||
.SH STYLES
|
||||
.TP
|
||||
* "fancy":
|
||||
Default style
|
||||
.TP
|
||||
* "retro":
|
||||
Old cpufetch style
|
||||
.TP
|
||||
* "legacy":
|
||||
Fallback style for terminals that do not support colors
|
||||
.SH LOGOS
|
||||
.TP
|
||||
cpufetch will try to adapt the logo size and the text to the terminal width. When the output (logo and text) is wider than the terminal width, cpufetch will print a smaller version of the logo (if it exists). This behavior can be overridden by \fB\-\-logo\-short\fR and \fB\-\-logo\-long\fR, which always sets the logo size as specified by the user, even if it is too big. After the logo selection (either automatically or set by the user), cpufetch will check again if the output fits in the terminal. If not, it will use a shorter name for the fields (the left part of the text). If, after all of this, the output still does not fit, cpufetch will cut the text and will only print the text until there is no space left in each line
|
||||
.SH EXAMPLES
|
||||
.TP
|
||||
Run cpufetch with Intel color scheme:
|
||||
.IP
|
||||
\&./cpufetch \fB\-\-color\fR intel
|
||||
.TP
|
||||
Run cpufetch with a custom color scheme:
|
||||
.IP
|
||||
\&./cpufetch \fB\-\-color\fR 239,90,45:210,200,200:0,0,0:100,200,45:0,200,200
|
||||
.SH BUGS
|
||||
.TP
|
||||
Report bugs to https://github.com/Dr\-Noob/cpufetch/issues
|
||||
.SH NOTE
|
||||
.TP
|
||||
Peak performance information is NOT accurate. cpufetch computes peak performance using the max frequency of the CPU. However, to compute the peak performance, you need to know the frequency of the CPU running AVX code. This value is not be fetched by cpufetch since it depends on each specific CPU. To correctly measure peak performance, see: https://github.com/Dr\-Noob/peakperf
|
||||
57
cpufetch.8
Normal file
57
cpufetch.8
Normal file
@@ -0,0 +1,57 @@
|
||||
.TH man 8 "1 Sep 2020" "0.7" "cpufetch man page"
|
||||
.SH NAME
|
||||
cpufetch \- Simplistic yet fancy CPU architecture fetching tool
|
||||
.SH SYNOPSIS
|
||||
cpufetch [--version] [--help] [--levels] [--style fancy|retro|legacy] [--color intel|amd|'R,G,B:R,G,B:R,G,B:R,G,B']
|
||||
.SH DESCRIPTION
|
||||
cpufetch will print CPU information, for which will query CPUID instructions and udev directories on Linux as a fallback method. Some of this features are:
|
||||
.IP \[bu] 2
|
||||
Name
|
||||
.IP \[bu]
|
||||
Frequency
|
||||
.IP \[bu]
|
||||
Number of cores (Physical and Logical)
|
||||
.IP \[bu]
|
||||
Cache sizes
|
||||
.IP \[bu]
|
||||
Theoretical peak performance in floating point operations per second (FLOP/s)
|
||||
.SH OPTIONS
|
||||
.TP
|
||||
\fB\-\-style\fR \f[I][intel|amd|R,G,B:R,G,B:R,G,B:R,G,B]\f[]
|
||||
Set the color scheme. By default, cpufetch uses the system color scheme. This option lets the user use different colors to print the CPU art:
|
||||
.IP \[bu]
|
||||
\fB"intel"\fR: Use intel color scheme
|
||||
.IP \[bu]
|
||||
\fB"amd"\fR: Use amd color scheme
|
||||
.IP \[bu]
|
||||
\fBcustom\fR: If color do not match "intel" or "amd", a custom scheme can be specified: 4 colors must be given in RGB with the format: R,G,B:R,G,B:...
|
||||
These colors correspond to CPU art color (2 colors) and for the text colors (following 2)
|
||||
.TP
|
||||
\fB\-\-style\fR \f[I]STYLE\f[]
|
||||
Specify the style of ascii logo:
|
||||
.IP \[bu]
|
||||
\fB"fancy"\fR: Default style
|
||||
.IP \[bu]
|
||||
\fB"retro"\fR: Old cpufetch style
|
||||
.IP \[bu]
|
||||
\fB"legacy"\fR: Fallback style for terminals that does not support colors
|
||||
.TP
|
||||
\fB\-\-levels\fR
|
||||
Prints CPUID levels and CPU name
|
||||
.TP
|
||||
\fB\-\-verbose\fR
|
||||
Prints extra information (if available) about how cpufetch tried fetching information
|
||||
.TP
|
||||
\fB\-\-help\fR
|
||||
Prints help
|
||||
.TP
|
||||
\fB\-\-version\fR
|
||||
Prints cpufetch version
|
||||
.SH BUGS
|
||||
Bugs should be posted on: https://github.com/Dr-Noob/cpufetch/issues
|
||||
.SH NOTES
|
||||
Peak performance information is NOT accurate. cpufetch computes peak performance using the max
|
||||
frequency. However, to properly compute peak performance, you need to know the frequency of the
|
||||
CPU running AVX code, which is not be fetched by cpufetch since it depends on each specific CPU.
|
||||
.SH AUTHOR
|
||||
Dr-Noob (https://github.com/Dr-Noob)
|
||||
@@ -11,7 +11,7 @@ Microarchitecture information is acquired from the Main ID Register (MIDR) [[2](
|
||||
- `CPU part`
|
||||
- `CPU revision`
|
||||
|
||||
The MIDR register can be built with this information. Another possible approach is to read MIDR directly from `/sys/devices/system/cpu/cpu*/regs/identification/midr_el1`
|
||||
The MIDR register can be built with this information. Another posible approach is to read MIDR directly from `/sys/devices/system/cpu/cpu*/regs/identification/midr_el1`
|
||||
|
||||
With the MIDR available, the approach is the same as the one used in x86_64 architectures. cpufetch has a file that acts like a database that tries to match the MIDR register with the specific CPU microarchitecture.
|
||||
|
||||
|
||||
@@ -1,26 +0,0 @@
|
||||
### 2. How to get CPU microarchitecture?
|
||||
__Involved code: [get_uarch_from_pvr (uarch.c)](https://github.com/Dr-Noob/cpufetch/src/ppc/uarch.c)__
|
||||
|
||||
Microarchitecture is deduced from the PVR register, which is read using the `mfpvr` instruction. The correspondence between the PVR and the specific microarchitecture has been implemented using the values in `arch/powerpc/kernel/cputable.c` in the Linux kernel. Some of them have been removed. The manufacturing process has been queried by searching on the internet.
|
||||
|
||||
### 3. How to get CPU topology?
|
||||
__Involved code: [get_topology_info (ppc.c)](https://github.com/Dr-Noob/cpufetch/src/ppc/ppc.c)__
|
||||
|
||||
The total number of cores is queried using `sysconf(_SC_NPROCESSORS_ONLN)`. Then, with the number of sockets and the number of physical cores, we can calculate the number of threads per core.
|
||||
|
||||
The number of sockets is queried using `/sys/devices/system/cpu/cpu*/topology/physical_package_id`. Once this file has been read for all of the cores, a simple custom algorithm is used to determine the number of sockets.
|
||||
|
||||
The number of physical cores is queried using `/sys/devices/system/cpu/cpu*/topology/core_id`. Again, a custom algorithm is used to determine the number of physical cores.
|
||||
|
||||
### 4. How to get the frequency?
|
||||
Frequency is read directly from `/sys/devices/system/cpu/cpu*/cpufreq/cpuinfo_max_freq`
|
||||
|
||||
### 5. How to get cache size and topology?
|
||||
Cache size is retrieved directly from Linux (using `/sys/devices/system/cpu/cpu0/cache/index*/size`).
|
||||
|
||||
To find the cache topology, the files `/sys/devices/system/cpu/cpu0/cache/index*/shared_cpu_map` are used, and a custom algorithm is used to determine how many caches are there at each level.
|
||||
|
||||
_NOTE_: To avoid Linux dependencies at this point, it looks like it is possible to derive the cache size and topology from the microarchitecture. For example, in the POWER9 architecture, wikichip assumes that all the POWER9 CPUs have the same cache size for each core and topology [[1](#references)].
|
||||
|
||||
#### References
|
||||
- [1] [POWER9 - wikichip](https://en.wikichip.org/wiki/ibm/microarchitectures/power9)
|
||||
@@ -1,14 +1,13 @@
|
||||
# cpufetch programming documentation (v0.98)
|
||||
# cpufetch programming documentation (v0.94)
|
||||
This documentation explains how cpufetch works internally and all the design decisions I made. This document intends to be useful for me in the future, for everyone interested in the project, and for anyone who is trying to obtain any specific information from the CPU. In this way, this can be used as a manual or a page that collects interesting material in this area.
|
||||
|
||||
### 1. Basics
|
||||
cpufetch works for __x86_64__ (Intel and AMD), __ARM__ and __PowerPC__ CPUs. However, cpufetch is expected to work better on x86_64, because the codebase is older and has been tested much more than the ARM and PowerPC versions. Depending on the architecture, cpufetch choose certain files to be compiled. A summarized tree of the source code of cpufetch is shown below.
|
||||
cpufetch works for __x86_64__ (Intel and AMD) and __ARM__ CPUs. However, cpufetch is expected to work better on x86_64, because the codebase is older and has been tested much more than the ARM version. Other kinds of x86_64 CPU are not supported (I don't think supporting other CPUs may pay off). Depending on the architecture, cpufetch choose certain files to be compiled. A summarized tree of the source code of cpufetch is shown below.
|
||||
|
||||
```
|
||||
cpufetch/
|
||||
├── doc
|
||||
│ ├── DOCUMENTATION_ARM.md
|
||||
| ├── DOCUMENTATION_PPC.md
|
||||
│ ├── DOCUMENTATION_X86.md
|
||||
│ └── README.md
|
||||
├── Makefile
|
||||
@@ -20,22 +19,17 @@ cpufetch/
|
||||
│ └── other files ...
|
||||
├── common/
|
||||
│ └── common files ...
|
||||
├── ppc/
|
||||
| ├── ppc.c
|
||||
| ├── ppc.h
|
||||
| └── other files ...
|
||||
└── x86/
|
||||
├── cpuid.c
|
||||
├── cpuid.h
|
||||
└── other files ...
|
||||
```
|
||||
|
||||
Source code is divided into four directories:
|
||||
Source code is divided into three directories:
|
||||
|
||||
- `common/`: Source code shared between all architectures
|
||||
- `arm/`: ARM source code
|
||||
- `ppc/`: PowerPC source code
|
||||
- `x86/`: x86 source code
|
||||
- `common/`: Source code shared between x86 and ARM
|
||||
- `arm/`: ARM dependant source code
|
||||
- `x86/`: x86_64 dependant source code
|
||||
|
||||
##### 1.1 Basics (x86_64)
|
||||
|
||||
@@ -56,14 +50,10 @@ struct cpuInfo {
|
||||
To use any CPUID leaf, cpufetch always needs to check that it is supported in the current CPU.
|
||||
|
||||
##### 1.2 Basics (ARM)
|
||||
In ARM, __cpufetch works using the MIDR register and Linux filesystem__. MIDR (Main ID Register) is read from `/proc/cpuinfo`. It allows the detection of the microarchitecture of the cores. Furthermore, Linux filesystem `/sys/devices/system/cpu/` is used to fetch the number of cores and other information. This is the main reason to explain __why `cpufetch` for ARM only works on Linux systems.__
|
||||
In ARM, __cpufetch works using the MIDR register and Linux filesystem__. MIDR (Main ID Register) is read from `/proc/cpuinfo`. It allows the detection of the microarchitecture of the cores. Furthermore, Linux filesystem `/sys/devices/system/cpu/` is used to fetch the number of cores and other information. This is the main reason to explain __why `cpufetch` only works on Linux kernel based systems.__
|
||||
|
||||
##### 1.3 Basics (PowerPC)
|
||||
In PowerPC, __cpufetch works using the PVR register and Linux filesystem__. PVR (Processor Version Register) is read using assembly and it is used to identify the microarchitecture of the CPU. Linux is also used to query the rest of the information, like the CPU topology, frequency, etc. This is the main reason to explain __why `cpufetch` for PowerPC only works on Linux systems.__
|
||||
##### 1.3 Documentation organization
|
||||
The rest of the documentation is divided into x86 and ARM architectures since each one needs different implementations:
|
||||
|
||||
##### 1.4 Documentation organization
|
||||
The rest of the documentation is divided in specific files for each architecture, since each one needs different implementations:
|
||||
|
||||
- [DOCUMENTATION_ARM.md](https://github.com/Dr-Noob/cpufetch/blob/master/doc/DOCUMENTATION_ARM.md)
|
||||
- [DOCUMENTATION_PPC.md](https://github.com/Dr-Noob/cpufetch/blob/master/doc/DOCUMENTATION_PPC.md)
|
||||
- [DOCUMENTATION_X86.md](https://github.com/Dr-Noob/cpufetch/blob/master/doc/DOCUMENTATION_X86.md)
|
||||
- [DOCUMENTATION_ARM.md](https://github.com/Dr-Noob/cpufetch/blob/master/doc/DOCUMENTATION_ARM.md)
|
||||
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 192 KiB |
BIN
pictures/cascade_lake.png
Normal file
BIN
pictures/cascade_lake.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 42 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 76 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 62 KiB After Width: | Height: | Size: 33 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 1.7 MiB |
Binary file not shown.
|
Before Width: | Height: | Size: 268 KiB |
BIN
pictures/exynos.png
Normal file
BIN
pictures/exynos.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 44 KiB |
BIN
pictures/i9.png
BIN
pictures/i9.png
Binary file not shown.
|
Before Width: | Height: | Size: 32 KiB After Width: | Height: | Size: 34 KiB |
BIN
pictures/ibm.png
BIN
pictures/ibm.png
Binary file not shown.
|
Before Width: | Height: | Size: 47 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 162 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 107 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 42 KiB |
375
src/arm/midr.c
375
src/arm/midr.c
@@ -4,29 +4,38 @@
|
||||
#include <assert.h>
|
||||
#include <stdbool.h>
|
||||
#include <errno.h>
|
||||
|
||||
#ifdef __linux__
|
||||
#include <sys/auxv.h>
|
||||
#include <asm/hwcap.h>
|
||||
#include "../common/freq.h"
|
||||
#elif defined __APPLE__ || __MACH__
|
||||
#include "../common/sysctl.h"
|
||||
#endif
|
||||
|
||||
#include "../common/global.h"
|
||||
#include "../common/soc.h"
|
||||
#include "../common/args.h"
|
||||
#include "udev.h"
|
||||
#include "midr.h"
|
||||
#include "uarch.h"
|
||||
#include "sve.h"
|
||||
#include "soc.h"
|
||||
|
||||
bool cores_are_equal(int c1pos, int c2pos, uint32_t* midr_array, int32_t* freq_array) {
|
||||
return midr_array[c1pos] == midr_array[c2pos] && freq_array[c1pos] == freq_array[c2pos];
|
||||
#define STRING_UNKNOWN "Unknown"
|
||||
|
||||
void init_cache_struct(struct cache* cach) {
|
||||
cach->L1i = malloc(sizeof(struct cach));
|
||||
cach->L1d = malloc(sizeof(struct cach));
|
||||
cach->L2 = malloc(sizeof(struct cach));
|
||||
cach->L3 = malloc(sizeof(struct cach));
|
||||
|
||||
cach->cach_arr = malloc(sizeof(struct cach*) * 4);
|
||||
cach->cach_arr[0] = cach->L1i;
|
||||
cach->cach_arr[1] = cach->L1d;
|
||||
cach->cach_arr[2] = cach->L2;
|
||||
cach->cach_arr[3] = cach->L3;
|
||||
|
||||
cach->max_cache_level = 0;
|
||||
cach->L1i->exists = false;
|
||||
cach->L1d->exists = false;
|
||||
cach->L2->exists = false;
|
||||
cach->L3->exists = false;
|
||||
}
|
||||
|
||||
struct cache* get_cache_info(struct cpuInfo* cpu) {
|
||||
struct cache* cach = emalloc(sizeof(struct cache));
|
||||
struct cache* cach = malloc(sizeof(struct cache));
|
||||
init_cache_struct(cach);
|
||||
|
||||
cach->max_cache_level = 2;
|
||||
@@ -40,26 +49,19 @@ struct cache* get_cache_info(struct cpuInfo* cpu) {
|
||||
}
|
||||
|
||||
struct frequency* get_frequency_info(uint32_t core) {
|
||||
struct frequency* freq = emalloc(sizeof(struct frequency));
|
||||
struct frequency* freq = malloc(sizeof(struct frequency));
|
||||
|
||||
freq->measured = false;
|
||||
freq->base = UNKNOWN_DATA;
|
||||
freq->max = get_max_freq_from_file(core);
|
||||
#ifdef __linux__
|
||||
if (freq->max == UNKNOWN_DATA || measure_max_frequency_flag()) {
|
||||
if (freq->max == UNKNOWN_DATA)
|
||||
printWarn("Unable to find max frequency from udev, measuring CPU frequency");
|
||||
freq->max = measure_max_frequency(core);
|
||||
freq->measured = true;
|
||||
}
|
||||
#endif
|
||||
freq->base = UNKNOWN_FREQ;
|
||||
freq->max = get_max_freq_from_file(core, false);
|
||||
|
||||
return freq;
|
||||
}
|
||||
|
||||
struct topology* get_topology_info(struct cpuInfo* cpu, struct cache* cach, uint32_t* midr_array, int32_t* freq_array, int socket_idx, int ncores) {
|
||||
struct topology* topo = emalloc(sizeof(struct topology));
|
||||
init_topology_struct(topo, cach);
|
||||
struct topology* get_topology_info(struct cpuInfo* cpu, struct cache* cach, uint32_t* midr_array, int socket_idx, int ncores) {
|
||||
struct topology* topo = malloc(sizeof(struct topology));
|
||||
|
||||
topo->cach = cach;
|
||||
topo->total_cores = 0;
|
||||
|
||||
int sockets_seen = 0;
|
||||
int first_core_idx = 0;
|
||||
@@ -67,7 +69,7 @@ struct topology* get_topology_info(struct cpuInfo* cpu, struct cache* cach, uint
|
||||
int cores_in_socket = 0;
|
||||
|
||||
while(socket_idx + 1 > sockets_seen) {
|
||||
if(currrent_core_idx < ncores && cores_are_equal(first_core_idx, currrent_core_idx, midr_array, freq_array)) {
|
||||
if(midr_array[first_core_idx] == midr_array[currrent_core_idx] && currrent_core_idx < ncores) {
|
||||
currrent_core_idx++;
|
||||
cores_in_socket++;
|
||||
}
|
||||
@@ -82,31 +84,8 @@ struct topology* get_topology_info(struct cpuInfo* cpu, struct cache* cach, uint
|
||||
return topo;
|
||||
}
|
||||
|
||||
int64_t get_peak_performance(struct cpuInfo* cpu) {
|
||||
struct cpuInfo* ptr = cpu;
|
||||
|
||||
//First check we have consistent data
|
||||
for(int i=0; i < cpu->num_cpus; ptr = ptr->next_cpu, i++) {
|
||||
if(get_freq(ptr->freq) == UNKNOWN_DATA) {
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
int64_t total_flops = 0;
|
||||
ptr = cpu;
|
||||
|
||||
for(int i=0; i < cpu->num_cpus; ptr = ptr->next_cpu, i++) {
|
||||
int vpus = get_number_of_vpus(ptr);
|
||||
int vpus_width = get_vpus_width(ptr);
|
||||
bool has_fma = has_fma_support(ptr);
|
||||
|
||||
int64_t flops = ptr->topo->total_cores * get_freq(ptr->freq) * 1000000 * vpus * (vpus_width/32);
|
||||
if(has_fma) flops = flops * 2;
|
||||
|
||||
total_flops += flops;
|
||||
}
|
||||
|
||||
return total_flops;
|
||||
bool cores_are_equal(int c1pos, int c2pos, uint32_t* midr_array, int32_t* freq_array) {
|
||||
return midr_array[c1pos] == midr_array[c2pos] && freq_array[c1pos] == freq_array[c2pos];
|
||||
}
|
||||
|
||||
uint32_t fill_ids_from_midr(uint32_t* midr_array, int32_t* freq_array, uint32_t* ids_array, int len) {
|
||||
@@ -148,14 +127,13 @@ void init_cpu_info(struct cpuInfo* cpu) {
|
||||
// true...
|
||||
// ARM32 https://elixir.bootlin.com/linux/latest/source/arch/arm/include/uapi/asm/hwcap.h
|
||||
// ARM64 https://elixir.bootlin.com/linux/latest/source/arch/arm64/include/uapi/asm/hwcap.h
|
||||
struct features* get_features_info(void) {
|
||||
struct features* feat = emalloc(sizeof(struct features));
|
||||
struct features* get_features_info() {
|
||||
struct features* feat = malloc(sizeof(struct features));
|
||||
bool *ptr = &(feat->AES);
|
||||
for(uint32_t i = 0; i < sizeof(struct features)/sizeof(bool); i++, ptr++) {
|
||||
*ptr = false;
|
||||
}
|
||||
|
||||
#ifdef __linux__
|
||||
errno = 0;
|
||||
long hwcaps = getauxval(AT_HWCAP);
|
||||
|
||||
@@ -169,17 +147,6 @@ struct features* get_features_info(void) {
|
||||
feat->SHA1 = hwcaps & HWCAP_SHA1;
|
||||
feat->SHA2 = hwcaps & HWCAP_SHA2;
|
||||
feat->NEON = hwcaps & HWCAP_ASIMD;
|
||||
feat->SVE = hwcaps & HWCAP_SVE;
|
||||
|
||||
hwcaps = getauxval(AT_HWCAP2);
|
||||
if (errno == ENOENT) {
|
||||
printWarn("Unable to retrieve AT_HWCAP2 using getauxval");
|
||||
}
|
||||
else {
|
||||
#ifdef HWCAP2_SVE2
|
||||
feat->SVE2 = hwcaps & HWCAP2_SVE2;
|
||||
#endif
|
||||
}
|
||||
}
|
||||
#else
|
||||
else {
|
||||
@@ -195,36 +162,21 @@ struct features* get_features_info(void) {
|
||||
feat->CRC32 = hwcaps & HWCAP2_CRC32;
|
||||
feat->SHA1 = hwcaps & HWCAP2_SHA1;
|
||||
feat->SHA2 = hwcaps & HWCAP2_SHA2;
|
||||
feat->SVE = false;
|
||||
feat->SVE2 = false;
|
||||
}
|
||||
#endif // ifdef __aarch64__
|
||||
#elif defined __APPLE__ || __MACH__
|
||||
// Must be M1
|
||||
feat->AES = true;
|
||||
feat->CRC32 = true;
|
||||
feat->SHA1 = true;
|
||||
feat->SHA2 = true;
|
||||
feat->NEON = true;
|
||||
feat->SVE = false;
|
||||
feat->SVE2 = false;
|
||||
#endif // ifdef __linux__
|
||||
|
||||
if (feat->SVE || feat->SVE2) {
|
||||
feat->cntb = sve_cntb();
|
||||
}
|
||||
#endif
|
||||
|
||||
return feat;
|
||||
}
|
||||
|
||||
#ifdef __linux__
|
||||
struct cpuInfo* get_cpu_info_linux(struct cpuInfo* cpu) {
|
||||
struct cpuInfo* get_cpu_info() {
|
||||
struct cpuInfo* cpu = malloc(sizeof(struct cpuInfo));
|
||||
init_cpu_info(cpu);
|
||||
|
||||
int ncores = get_ncores_from_cpuinfo();
|
||||
bool success = false;
|
||||
int32_t* freq_array = emalloc(sizeof(uint32_t) * ncores);
|
||||
uint32_t* midr_array = emalloc(sizeof(uint32_t) * ncores);
|
||||
uint32_t* ids_array = emalloc(sizeof(uint32_t) * ncores);
|
||||
int32_t* freq_array = malloc(sizeof(uint32_t) * ncores);
|
||||
uint32_t* midr_array = malloc(sizeof(uint32_t) * ncores);
|
||||
uint32_t* ids_array = malloc(sizeof(uint32_t) * ncores);
|
||||
|
||||
for(int i=0; i < ncores; i++) {
|
||||
midr_array[i] = get_midr_from_cpuinfo(i, &success);
|
||||
@@ -234,8 +186,8 @@ struct cpuInfo* get_cpu_info_linux(struct cpuInfo* cpu) {
|
||||
midr_array[i] = midr_array[0];
|
||||
}
|
||||
|
||||
freq_array[i] = get_max_freq_from_file(i);
|
||||
if(freq_array[i] == UNKNOWN_DATA) {
|
||||
freq_array[i] = get_max_freq_from_file(i, false);
|
||||
if(freq_array[i] == UNKNOWN_FREQ) {
|
||||
printWarn("Unable to fetch max frequency for core %d. This is probably because the core is offline", i);
|
||||
freq_array[i] = freq_array[0];
|
||||
}
|
||||
@@ -247,7 +199,7 @@ struct cpuInfo* get_cpu_info_linux(struct cpuInfo* cpu) {
|
||||
int tmp_midr_idx = 0;
|
||||
for(uint32_t i=0; i < sockets; i++) {
|
||||
if(i > 0) {
|
||||
ptr->next_cpu = emalloc(sizeof(struct cpuInfo));
|
||||
ptr->next_cpu = malloc(sizeof(struct cpuInfo));
|
||||
ptr = ptr->next_cpu;
|
||||
init_cpu_info(ptr);
|
||||
|
||||
@@ -262,211 +214,67 @@ struct cpuInfo* get_cpu_info_linux(struct cpuInfo* cpu) {
|
||||
ptr->feat = get_features_info();
|
||||
ptr->freq = get_frequency_info(midr_idx);
|
||||
ptr->cach = get_cache_info(ptr);
|
||||
ptr->topo = get_topology_info(ptr, ptr->cach, midr_array, freq_array, i, ncores);
|
||||
ptr->topo = get_topology_info(ptr, ptr->cach, midr_array, i, ncores);
|
||||
}
|
||||
|
||||
cpu->num_cpus = sockets;
|
||||
cpu->hv = emalloc(sizeof(struct hypervisor));
|
||||
cpu->hv = malloc(sizeof(struct hypervisor));
|
||||
cpu->hv->present = false;
|
||||
cpu->soc = get_soc(cpu);
|
||||
cpu->peak_performance = get_peak_performance(cpu);
|
||||
cpu->soc = get_soc();
|
||||
|
||||
return cpu;
|
||||
}
|
||||
|
||||
#elif defined __APPLE__ || __MACH__
|
||||
void fill_cpu_info_firestorm_icestorm(struct cpuInfo* cpu, uint32_t pcores, uint32_t ecores) {
|
||||
// 1. Fill ICESTORM
|
||||
struct cpuInfo* ice = cpu;
|
||||
|
||||
ice->midr = MIDR_APPLE_M1_ICESTORM;
|
||||
ice->arch = get_uarch_from_midr(ice->midr, ice);
|
||||
ice->cach = get_cache_info(ice);
|
||||
ice->feat = get_features_info();
|
||||
ice->topo = malloc(sizeof(struct topology));
|
||||
ice->topo->cach = ice->cach;
|
||||
ice->topo->total_cores = ecores;
|
||||
ice->freq = malloc(sizeof(struct frequency));
|
||||
ice->freq->base = UNKNOWN_DATA;
|
||||
ice->freq->max = 2064;
|
||||
ice->hv = malloc(sizeof(struct hypervisor));
|
||||
ice->hv->present = false;
|
||||
ice->next_cpu = malloc(sizeof(struct cpuInfo));
|
||||
|
||||
// 2. Fill FIRESTORM
|
||||
struct cpuInfo* fire = ice->next_cpu;
|
||||
fire->midr = MIDR_APPLE_M1_FIRESTORM;
|
||||
fire->arch = get_uarch_from_midr(fire->midr, fire);
|
||||
fire->cach = get_cache_info(fire);
|
||||
fire->feat = get_features_info();
|
||||
fire->topo = malloc(sizeof(struct topology));
|
||||
fire->topo->cach = fire->cach;
|
||||
fire->topo->total_cores = pcores;
|
||||
fire->freq = malloc(sizeof(struct frequency));
|
||||
fire->freq->base = UNKNOWN_DATA;
|
||||
fire->freq->max = 3200;
|
||||
fire->hv = malloc(sizeof(struct hypervisor));
|
||||
fire->hv->present = false;
|
||||
fire->next_cpu = NULL;
|
||||
}
|
||||
|
||||
void fill_cpu_info_avalanche_blizzard(struct cpuInfo* cpu, uint32_t pcores, uint32_t ecores) {
|
||||
// 1. Fill BLIZZARD
|
||||
struct cpuInfo* bli = cpu;
|
||||
|
||||
bli->midr = MIDR_APPLE_M2_BLIZZARD;
|
||||
bli->arch = get_uarch_from_midr(bli->midr, bli);
|
||||
bli->cach = get_cache_info(bli);
|
||||
bli->feat = get_features_info();
|
||||
bli->topo = malloc(sizeof(struct topology));
|
||||
bli->topo->cach = bli->cach;
|
||||
bli->topo->total_cores = ecores;
|
||||
bli->freq = malloc(sizeof(struct frequency));
|
||||
bli->freq->base = UNKNOWN_DATA;
|
||||
bli->freq->max = 2800;
|
||||
bli->hv = malloc(sizeof(struct hypervisor));
|
||||
bli->hv->present = false;
|
||||
bli->next_cpu = malloc(sizeof(struct cpuInfo));
|
||||
|
||||
// 2. Fill AVALANCHE
|
||||
struct cpuInfo* ava = bli->next_cpu;
|
||||
ava->midr = MIDR_APPLE_M2_AVALANCHE;
|
||||
ava->arch = get_uarch_from_midr(ava->midr, ava);
|
||||
ava->cach = get_cache_info(ava);
|
||||
ava->feat = get_features_info();
|
||||
ava->topo = malloc(sizeof(struct topology));
|
||||
ava->topo->cach = ava->cach;
|
||||
ava->topo->total_cores = pcores;
|
||||
ava->freq = malloc(sizeof(struct frequency));
|
||||
ava->freq->base = UNKNOWN_DATA;
|
||||
ava->freq->max = 3500;
|
||||
ava->hv = malloc(sizeof(struct hypervisor));
|
||||
ava->hv->present = false;
|
||||
ava->next_cpu = NULL;
|
||||
}
|
||||
|
||||
void fill_cpu_info_everest_sawtooth(struct cpuInfo* cpu, uint32_t pcores, uint32_t ecores) {
|
||||
// 1. Fill SAWTOOTH
|
||||
struct cpuInfo* saw = cpu;
|
||||
|
||||
saw->midr = MIDR_APPLE_M3_SAWTOOTH;
|
||||
saw->arch = get_uarch_from_midr(saw->midr, saw);
|
||||
saw->cach = get_cache_info(saw);
|
||||
saw->feat = get_features_info();
|
||||
saw->topo = malloc(sizeof(struct topology));
|
||||
saw->topo->cach = saw->cach;
|
||||
saw->topo->total_cores = ecores;
|
||||
saw->freq = malloc(sizeof(struct frequency));
|
||||
saw->freq->base = UNKNOWN_DATA;
|
||||
saw->freq->max = 2750;
|
||||
saw->hv = malloc(sizeof(struct hypervisor));
|
||||
saw->hv->present = false;
|
||||
saw->next_cpu = malloc(sizeof(struct cpuInfo));
|
||||
|
||||
// 2. Fill EVEREST
|
||||
struct cpuInfo* eve = saw->next_cpu;
|
||||
eve->midr = MIDR_APPLE_M3_EVEREST;
|
||||
eve->arch = get_uarch_from_midr(eve->midr, eve);
|
||||
eve->cach = get_cache_info(eve);
|
||||
eve->feat = get_features_info();
|
||||
eve->topo = malloc(sizeof(struct topology));
|
||||
eve->topo->cach = eve->cach;
|
||||
eve->topo->total_cores = pcores;
|
||||
eve->freq = malloc(sizeof(struct frequency));
|
||||
eve->freq->base = UNKNOWN_DATA;
|
||||
eve->freq->max = 4050;
|
||||
eve->hv = malloc(sizeof(struct hypervisor));
|
||||
eve->hv->present = false;
|
||||
eve->next_cpu = NULL;
|
||||
}
|
||||
|
||||
struct cpuInfo* get_cpu_info_mach(struct cpuInfo* cpu) {
|
||||
// https://developer.apple.com/documentation/kernel/1387446-sysctlbyname/determining_system_capabilities
|
||||
uint32_t nperflevels = get_sys_info_by_name("hw.nperflevels");
|
||||
|
||||
if((cpu->num_cpus = nperflevels) != 2) {
|
||||
printBug("Expected to find SoC with 2 perf levels, found: %d", cpu->num_cpus);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
uint32_t pcores = get_sys_info_by_name("hw.perflevel0.physicalcpu");
|
||||
uint32_t ecores = get_sys_info_by_name("hw.perflevel1.physicalcpu");
|
||||
if(ecores <= 0) {
|
||||
printBug("Expected to find a numer of ecores > 0, found: %d", ecores);
|
||||
return NULL;
|
||||
}
|
||||
if(pcores <= 0) {
|
||||
printBug("Expected to find a numer of pcores > 0, found: %d", pcores);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
uint32_t cpu_family = get_sys_info_by_name("hw.cpufamily");
|
||||
// Manually fill the cpuInfo assuming that
|
||||
// the CPU is an Apple SoC
|
||||
if(cpu_family == CPUFAMILY_ARM_FIRESTORM_ICESTORM) {
|
||||
fill_cpu_info_firestorm_icestorm(cpu, pcores, ecores);
|
||||
cpu->soc = get_soc(cpu);
|
||||
cpu->peak_performance = get_peak_performance(cpu);
|
||||
}
|
||||
else if(cpu_family == CPUFAMILY_ARM_AVALANCHE_BLIZZARD) {
|
||||
fill_cpu_info_avalanche_blizzard(cpu, pcores, ecores);
|
||||
cpu->soc = get_soc(cpu);
|
||||
cpu->peak_performance = get_peak_performance(cpu);
|
||||
}
|
||||
else if(cpu_family == CPUFAMILY_ARM_EVEREST_SAWTOOTH ||
|
||||
cpu_family == CPUFAMILY_ARM_EVEREST_SAWTOOTH_2 ||
|
||||
cpu_family == CPUFAMILY_ARM_EVEREST_SAWTOOTH_PRO ||
|
||||
cpu_family == CPUFAMILY_ARM_EVEREST_SAWTOOTH_MAX) {
|
||||
fill_cpu_info_everest_sawtooth(cpu, pcores, ecores);
|
||||
cpu->soc = get_soc(cpu);
|
||||
cpu->peak_performance = get_peak_performance(cpu);
|
||||
}
|
||||
else {
|
||||
printBugCheckRelease("Found invalid cpu_family: 0x%.8X", cpu_family);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return cpu;
|
||||
}
|
||||
#endif
|
||||
|
||||
struct cpuInfo* get_cpu_info(void) {
|
||||
struct cpuInfo* cpu = malloc(sizeof(struct cpuInfo));
|
||||
init_cpu_info(cpu);
|
||||
|
||||
#ifdef __linux__
|
||||
return get_cpu_info_linux(cpu);
|
||||
#elif defined __APPLE__ || __MACH__
|
||||
return get_cpu_info_mach(cpu);
|
||||
#endif
|
||||
}
|
||||
|
||||
char* get_str_topology(struct cpuInfo* cpu, struct topology* topo, bool dual_socket) {
|
||||
uint32_t size = 3+7+1;
|
||||
char* string = emalloc(sizeof(char)*size);
|
||||
char* string = malloc(sizeof(char)*size);
|
||||
snprintf(string, size, "%d cores", topo->total_cores);
|
||||
|
||||
return string;
|
||||
}
|
||||
|
||||
char* get_str_peak_performance(struct cpuInfo* cpu) {
|
||||
//7 for GFLOP/s and 6 for digits,eg 412.14
|
||||
uint32_t size = 7+6+1+1;
|
||||
assert(strlen(STRING_UNKNOWN)+1 <= size);
|
||||
char* string = malloc(sizeof(char)*size);
|
||||
struct cpuInfo* ptr = cpu;
|
||||
|
||||
//First check we have consistent data
|
||||
for(int i=0; i < cpu->num_cpus; ptr = ptr->next_cpu, i++) {
|
||||
if(get_freq(ptr->freq) == UNKNOWN_FREQ) {
|
||||
snprintf(string, strlen(STRING_UNKNOWN)+1, STRING_UNKNOWN);
|
||||
return string;
|
||||
}
|
||||
}
|
||||
|
||||
double flops = 0.0;
|
||||
|
||||
ptr = cpu;
|
||||
for(int i=0; i < cpu->num_cpus; ptr = ptr->next_cpu, i++) {
|
||||
flops += ptr->topo->total_cores * (get_freq(ptr->freq) * 1000000);
|
||||
}
|
||||
if(cpu->feat->NEON) flops = flops * 4;
|
||||
|
||||
if(flops >= (double)1000000000000.0)
|
||||
snprintf(string,size,"%.2f TFLOP/s",flops/1000000000000);
|
||||
else if(flops >= 1000000000.0)
|
||||
snprintf(string,size,"%.2f GFLOP/s",flops/1000000000);
|
||||
else
|
||||
snprintf(string,size,"%.2f MFLOP/s",flops/1000000);
|
||||
|
||||
return string;
|
||||
}
|
||||
|
||||
char* get_str_features(struct cpuInfo* cpu) {
|
||||
struct features* feat = cpu->feat;
|
||||
uint32_t max_len = strlen("NEON,SHA1,SHA2,AES,CRC32,SVE,SVE2,") + 1;
|
||||
char* string = malloc(sizeof(char) * 25);
|
||||
uint32_t len = 0;
|
||||
char* string = ecalloc(max_len, sizeof(char));
|
||||
|
||||
if(feat->NEON) {
|
||||
strcat(string, "NEON,");
|
||||
len += 5;
|
||||
}
|
||||
if(feat->SVE) {
|
||||
strcat(string, "SVE,");
|
||||
len += 4;
|
||||
}
|
||||
if(feat->SVE2) {
|
||||
strcat(string, "SVE2,");
|
||||
len += 5;
|
||||
}
|
||||
if(feat->SHA1) {
|
||||
strcat(string, "SHA1,");
|
||||
len += 5;
|
||||
@@ -498,7 +306,7 @@ void print_debug(struct cpuInfo* cpu) {
|
||||
|
||||
for(int i=0; i < ncores; i++) {
|
||||
printf("[Core %d] ", i);
|
||||
long freq = get_max_freq_from_file(i);
|
||||
long freq = get_max_freq_from_file(i, false);
|
||||
uint32_t midr = get_midr_from_cpuinfo(i, &success);
|
||||
if(!success) {
|
||||
printWarn("Unable to fetch MIDR for core %d. This is probably because the core is offline", i);
|
||||
@@ -507,27 +315,14 @@ void print_debug(struct cpuInfo* cpu) {
|
||||
else {
|
||||
printf("0x%.8X ", midr);
|
||||
}
|
||||
if(freq == UNKNOWN_DATA) {
|
||||
if(freq == UNKNOWN_FREQ) {
|
||||
printWarn("Unable to fetch max frequency for core %d. This is probably because the core is offline", i);
|
||||
printf("%ld MHz\n", get_max_freq_from_file(0));
|
||||
printf("%ld MHz\n", get_max_freq_from_file(0, false));
|
||||
}
|
||||
else {
|
||||
printf("%ld MHz\n", freq);
|
||||
}
|
||||
}
|
||||
|
||||
if (cpu->feat->SVE || cpu->feat->SVE2) {
|
||||
printf("- cntb: %d\n", (int) cpu->feat->cntb);
|
||||
}
|
||||
|
||||
#if defined(__APPLE__) || defined(__MACH__)
|
||||
printf("hw.cpufamily: 0x%.8X\n", get_sys_info_by_name("hw.cpufamily"));
|
||||
printf("hw.cpusubfamily: 0x%.8X\n", get_sys_info_by_name("hw.cpusubfamily"));
|
||||
printf("hw.nperflevels: %d\n", get_sys_info_by_name("hw.nperflevels"));
|
||||
printf("hw.physicalcpu: %d\n", get_sys_info_by_name("hw.physicalcpu"));
|
||||
printf("hw.perflevel0.physicalcpu: %d\n", get_sys_info_by_name("hw.perflevel0.physicalcpu"));
|
||||
printf("hw.perflevel1.physicalcpu: %d\n", get_sys_info_by_name("hw.perflevel1.physicalcpu"));
|
||||
#endif
|
||||
}
|
||||
|
||||
void free_topo_struct(struct topology* topo) {
|
||||
|
||||
@@ -3,10 +3,11 @@
|
||||
|
||||
#include "../common/cpu.h"
|
||||
|
||||
struct cpuInfo* get_cpu_info(void);
|
||||
struct cpuInfo* get_cpu_info();
|
||||
|
||||
uint32_t get_nsockets(struct topology* topo);
|
||||
char* get_str_topology(struct cpuInfo* cpu, struct topology* topo, bool dual_socket);
|
||||
char* get_str_peak_performance(struct cpuInfo* cpu);
|
||||
char* get_str_features(struct cpuInfo* cpu);
|
||||
|
||||
void print_debug(struct cpuInfo* cpu);
|
||||
|
||||
997
src/arm/soc.c
997
src/arm/soc.c
File diff suppressed because it is too large
Load Diff
@@ -1,10 +1,31 @@
|
||||
#ifndef __SOC_ARM__
|
||||
#define __SOC_ARM__
|
||||
#ifndef __SOC__
|
||||
#define __SOC__
|
||||
|
||||
#include "../common/cpu.h"
|
||||
#include "../common/soc.h"
|
||||
#include <stdint.h>
|
||||
|
||||
struct system_on_chip* get_soc(struct cpuInfo* cpu);
|
||||
typedef int32_t SOC;
|
||||
|
||||
enum {
|
||||
SOC_VENDOR_UNKNOWN,
|
||||
SOC_VENDOR_SNAPDRAGON,
|
||||
SOC_VENDOR_MEDIATEK,
|
||||
SOC_VENDOR_EXYNOS,
|
||||
SOC_VENDOR_KIRIN,
|
||||
SOC_VENDOR_BROADCOM
|
||||
};
|
||||
|
||||
struct system_on_chip {
|
||||
SOC soc_model;
|
||||
VENDOR soc_vendor;
|
||||
int32_t process;
|
||||
char* soc_name;
|
||||
char* raw_name;
|
||||
};
|
||||
|
||||
struct system_on_chip* get_soc();
|
||||
char* get_soc_name(struct system_on_chip* soc);
|
||||
VENDOR get_soc_vendor(struct system_on_chip* soc);
|
||||
char* get_str_process(struct system_on_chip* soc);
|
||||
|
||||
#endif
|
||||
|
||||
226
src/arm/socs.h
226
src/arm/socs.h
@@ -10,6 +10,7 @@ enum {
|
||||
SOC_BCM_2836,
|
||||
SOC_BCM_2837,
|
||||
SOC_BCM_2837B0,
|
||||
SOC_BCM_2711,
|
||||
SOC_BCM_21553,
|
||||
SOC_BCM_21553T,
|
||||
SOC_BCM_21663,
|
||||
@@ -19,8 +20,6 @@ enum {
|
||||
SOC_BCM_28145,
|
||||
SOC_BCM_2157,
|
||||
SOC_BCM_21654,
|
||||
SOC_BCM_2711,
|
||||
SOC_BCM_2712,
|
||||
// Hisilicon //
|
||||
SOC_HISILICON_3620,
|
||||
SOC_HISILICON_3630,
|
||||
@@ -29,10 +28,6 @@ enum {
|
||||
SOC_HISILICON_3670,
|
||||
SOC_HISILICON_3680,
|
||||
SOC_HISILICON_3690,
|
||||
SOC_HISILICON_9000S,
|
||||
// Kunpeng //
|
||||
SOC_KUNPENG_920,
|
||||
SOC_KUNPENG_930,
|
||||
// Exynos //
|
||||
SOC_EXYNOS_3475,
|
||||
SOC_EXYNOS_4210,
|
||||
@@ -68,23 +63,37 @@ enum {
|
||||
SOC_EXYNOS_980,
|
||||
SOC_EXYNOS_880,
|
||||
// Mediatek //
|
||||
SOC_MTK_MT5327,
|
||||
SOC_MTK_MT5329,
|
||||
SOC_MTK_MT5366,
|
||||
SOC_MTK_MT5389,
|
||||
SOC_MTK_MT5395,
|
||||
SOC_MTK_MT5396,
|
||||
SOC_MTK_MT5398,
|
||||
SOC_MTK_MT5505,
|
||||
SOC_MTK_MT5561,
|
||||
SOC_MTK_MT5580,
|
||||
SOC_MTK_MT5582,
|
||||
SOC_MTK_MT5592,
|
||||
SOC_MTK_MT5595,
|
||||
SOC_MTK_MT5596,
|
||||
SOC_MTK_MT5597,
|
||||
SOC_MTK_MT5889,
|
||||
SOC_MTK_MT5895,
|
||||
SOC_MTK_MT6889,
|
||||
SOC_MTK_MT6885Z,
|
||||
SOC_MTK_MT6853,
|
||||
SOC_MTK_MT6873,
|
||||
SOC_MTK_MT6875,
|
||||
SOC_MTK_MT6761D,
|
||||
SOC_MTK_MT6761,
|
||||
SOC_MTK_MT6762D,
|
||||
SOC_MTK_MT6755,
|
||||
SOC_MTK_MT6755M,
|
||||
SOC_MTK_MT6755T,
|
||||
SOC_MTK_MT6757,
|
||||
SOC_MTK_MT6762,
|
||||
SOC_MTK_MT6763V,
|
||||
SOC_MTK_MT6763T,
|
||||
SOC_MTK_MT6757CD,
|
||||
SOC_MTK_MT6758,
|
||||
SOC_MTK_MT6765,
|
||||
SOC_MTK_MT6771,
|
||||
SOC_MTK_MT6768,
|
||||
SOC_MTK_MT6771T,
|
||||
SOC_MTK_MT6771V,
|
||||
SOC_MTK_MT6779,
|
||||
SOC_MTK_MT6795,
|
||||
SOC_MTK_MT6795T,
|
||||
SOC_MTK_MT6797,
|
||||
SOC_MTK_MT6797M,
|
||||
SOC_MTK_MT6797D,
|
||||
SOC_MTK_MT6797T,
|
||||
SOC_MTK_MT6797X,
|
||||
SOC_MTK_MT6799,
|
||||
SOC_MTK_MT6515,
|
||||
SOC_MTK_MT6516,
|
||||
SOC_MTK_MT6517,
|
||||
@@ -114,51 +123,7 @@ enum {
|
||||
SOC_MTK_MT6750T,
|
||||
SOC_MTK_MT6752,
|
||||
SOC_MTK_MT6753,
|
||||
SOC_MTK_MT6755M,
|
||||
SOC_MTK_MT6755T,
|
||||
SOC_MTK_MT6757,
|
||||
SOC_MTK_MT6757CD,
|
||||
SOC_MTK_MT6758,
|
||||
SOC_MTK_MT6761,
|
||||
SOC_MTK_MT6761D,
|
||||
SOC_MTK_MT6762,
|
||||
SOC_MTK_MT6762D,
|
||||
SOC_MTK_MT6762G,
|
||||
SOC_MTK_MT6763T,
|
||||
SOC_MTK_MT6763V,
|
||||
SOC_MTK_MT6765,
|
||||
SOC_MTK_MT6765G,
|
||||
SOC_MTK_MT6765H,
|
||||
SOC_MTK_MT6768,
|
||||
SOC_MTK_MT6769H,
|
||||
SOC_MTK_MT6769T,
|
||||
SOC_MTK_MT6769V,
|
||||
SOC_MTK_MT6769Z,
|
||||
SOC_MTK_MT6771,
|
||||
SOC_MTK_MT6779V_CU,
|
||||
SOC_MTK_MT6779V_CV,
|
||||
SOC_MTK_MT6785V_CC,
|
||||
SOC_MTK_MT6785V_CD,
|
||||
SOC_MTK_MT6789,
|
||||
SOC_MTK_MT6795,
|
||||
SOC_MTK_MT6797,
|
||||
SOC_MTK_MT6797T,
|
||||
SOC_MTK_MT6797X,
|
||||
SOC_MTK_MT6799,
|
||||
SOC_MTK_MT6833,
|
||||
SOC_MTK_MT6850,
|
||||
SOC_MTK_MT6853,
|
||||
SOC_MTK_MT6853V,
|
||||
SOC_MTK_MT6873,
|
||||
SOC_MTK_MT6875,
|
||||
SOC_MTK_MT6879,
|
||||
SOC_MTK_MT6883Z,
|
||||
SOC_MTK_MT6885Z,
|
||||
SOC_MTK_MT6889,
|
||||
SOC_MTK_MT6889Z,
|
||||
SOC_MTK_MT6891,
|
||||
SOC_MTK_MT6893,
|
||||
SOC_MTK_MT6893Z,
|
||||
SOC_MTK_MT8121,
|
||||
SOC_MTK_MT8125,
|
||||
SOC_MTK_MT8127,
|
||||
@@ -173,25 +138,7 @@ enum {
|
||||
SOC_MTK_MT8581,
|
||||
SOC_MTK_MT8735,
|
||||
SOC_MTK_MT8765B,
|
||||
SOC_MTK_MT8781V,
|
||||
SOC_MTK_MT8783,
|
||||
SOC_MTK_MT9602,
|
||||
SOC_MTK_MT9612,
|
||||
SOC_MTK_MT9613,
|
||||
SOC_MTK_MT9615,
|
||||
SOC_MTK_MT9618,
|
||||
SOC_MTK_MT9632,
|
||||
SOC_MTK_MT9638,
|
||||
SOC_MTK_MT9652,
|
||||
SOC_MTK_MT9653,
|
||||
SOC_MTK_MT9675,
|
||||
SOC_MTK_MT9685,
|
||||
SOC_MTK_MT9686,
|
||||
SOC_MTK_MT9689,
|
||||
SOC_MTK_MT9902,
|
||||
SOC_MTK_MT9950,
|
||||
SOC_MTK_MT9972,
|
||||
SOC_MTK_MT9982,
|
||||
// Snapdragon //
|
||||
SOC_SNAPD_QSD8650,
|
||||
SOC_SNAPD_QSD8250,
|
||||
@@ -271,16 +218,11 @@ enum {
|
||||
SOC_SNAPD_SDM660,
|
||||
SOC_SNAPD_SM6115,
|
||||
SOC_SNAPD_SM6125,
|
||||
SOC_SNAPD_SM6375_AC,
|
||||
SOC_SNAPD_SM6450,
|
||||
SOC_SNAPD_SDM670,
|
||||
SOC_SNAPD_SM6150,
|
||||
SOC_SNAPD_SM6350,
|
||||
SOC_SNAPD_SDM710,
|
||||
SOC_SNAPD_SDM712,
|
||||
SOC_SNAPD_SM4375,
|
||||
SOC_SNAPD_SM4450,
|
||||
SOC_SNAPD_SM4635,
|
||||
SOC_SNAPD_SM7125,
|
||||
SOC_SNAPD_SM7150_AA,
|
||||
SOC_SNAPD_SM7150_AB,
|
||||
@@ -289,11 +231,6 @@ enum {
|
||||
SOC_SNAPD_SM7250_AA,
|
||||
SOC_SNAPD_SM7250_AB,
|
||||
SOC_SNAPD_SM7250_AC,
|
||||
SOC_SNAPD_SM7435_AB,
|
||||
SOC_SNAPD_SM7450,
|
||||
SOC_SNAPD_SM7475,
|
||||
SOC_SNAPD_SM7550_AB,
|
||||
SOC_SNAPD_SM7675_AB,
|
||||
SOC_SNAPD_MSM8974AA,
|
||||
SOC_SNAPD_MSM8974AB,
|
||||
SOC_SNAPD_MSM8974AC,
|
||||
@@ -313,105 +250,14 @@ enum {
|
||||
SOC_SNAPD_SM8250,
|
||||
SOC_SNAPD_SM8250_AB,
|
||||
SOC_SNAPD_SM8350,
|
||||
SOC_SNAPD_SM8450,
|
||||
SOC_SNAPD_SM8475,
|
||||
SOC_SNAPD_SM8550_AB,
|
||||
SOC_SNAPD_SM8635,
|
||||
SOC_SNAPD_SM8650_AB,
|
||||
// APPLE
|
||||
SOC_APPLE_M1,
|
||||
SOC_APPLE_M1_PRO,
|
||||
SOC_APPLE_M1_MAX,
|
||||
SOC_APPLE_M1_ULTRA,
|
||||
SOC_APPLE_M2,
|
||||
SOC_APPLE_M2_PRO,
|
||||
SOC_APPLE_M2_MAX,
|
||||
SOC_APPLE_M2_ULTRA,
|
||||
SOC_APPLE_M3,
|
||||
SOC_APPLE_M3_PRO,
|
||||
SOC_APPLE_M3_MAX,
|
||||
// ALLWINNER
|
||||
SOC_ALLWINNER_A10,
|
||||
SOC_ALLWINNER_A13,
|
||||
SOC_ALLWINNER_A10S,
|
||||
SOC_ALLWINNER_A20,
|
||||
SOC_ALLWINNER_A23,
|
||||
SOC_ALLWINNER_A31,
|
||||
SOC_ALLWINNER_A31S,
|
||||
SOC_ALLWINNER_A33,
|
||||
SOC_ALLWINNER_A40,
|
||||
SOC_ALLWINNER_A50,
|
||||
SOC_ALLWINNER_A64,
|
||||
SOC_ALLWINNER_A80,
|
||||
SOC_ALLWINNER_A83T,
|
||||
SOC_ALLWINNER_V3S,
|
||||
SOC_ALLWINNER_HZP,
|
||||
SOC_ALLWINNER_H2PLUS,
|
||||
SOC_ALLWINNER_S3,
|
||||
SOC_ALLWINNER_H3,
|
||||
SOC_ALLWINNER_H8,
|
||||
SOC_ALLWINNER_H5,
|
||||
SOC_ALLWINNER_H6,
|
||||
SOC_ALLWINNER_H64,
|
||||
SOC_ALLWINNER_H616,
|
||||
SOC_ALLWINNER_H618,
|
||||
SOC_ALLWINNER_R8,
|
||||
SOC_ALLWINNER_R16,
|
||||
SOC_ALLWINNER_R40,
|
||||
SOC_ALLWINNER_R58,
|
||||
SOC_ALLWINNER_R328,
|
||||
// ROCKCHIP
|
||||
SOC_ROCKCHIP_3288,
|
||||
SOC_ROCKCHIP_3229,
|
||||
SOC_ROCKCHIP_3308,
|
||||
SOC_ROCKCHIP_3318,
|
||||
SOC_ROCKCHIP_3326,
|
||||
SOC_ROCKCHIP_3328,
|
||||
SOC_ROCKCHIP_3368,
|
||||
SOC_ROCKCHIP_3399,
|
||||
SOC_ROCKCHIP_3528,
|
||||
SOC_ROCKCHIP_3562,
|
||||
SOC_ROCKCHIP_3566,
|
||||
SOC_ROCKCHIP_3568,
|
||||
SOC_ROCKCHIP_3588,
|
||||
// GOOGLE
|
||||
SOC_GOOGLE_TENSOR,
|
||||
SOC_GOOGLE_TENSOR_G2,
|
||||
SOC_GOOGLE_TENSOR_G3,
|
||||
// NVIDIA,
|
||||
SOC_TEGRA_X1,
|
||||
// ALTRA
|
||||
SOC_AMPERE_ALTRA,
|
||||
// NXP
|
||||
SOC_NXP_IMX8QM,
|
||||
SOC_NXP_IMX8QP,
|
||||
SOC_NXP_IMX8MP,
|
||||
SOC_NXP_IMX8MN,
|
||||
SOC_NXP_IMX8MM,
|
||||
SOC_NXP_IMX8DXP,
|
||||
SOC_NXP_IMX8QXP,
|
||||
SOC_NXP_IMX93,
|
||||
// AMLOGIC
|
||||
SOC_AMLOGIC_A311D,
|
||||
// UNKNOWN
|
||||
SOC_MODEL_UNKNOWN
|
||||
};
|
||||
|
||||
inline static VENDOR get_soc_vendor_from_soc(SOC soc) {
|
||||
if(soc >= SOC_BCM_2835 && soc <= SOC_BCM_2712) return SOC_VENDOR_BROADCOM;
|
||||
else if(soc >= SOC_HISILICON_3620 && soc <= SOC_HISILICON_9000S) return SOC_VENDOR_KIRIN;
|
||||
else if(soc >= SOC_KUNPENG_920 && soc <= SOC_KUNPENG_930) return SOC_VENDOR_KUNPENG;
|
||||
if(soc >= SOC_BCM_2835 && soc <= SOC_BCM_21654) return SOC_VENDOR_BROADCOM;
|
||||
else if(soc >= SOC_HISILICON_3620 && soc <= SOC_HISILICON_3690) return SOC_VENDOR_KIRIN;
|
||||
else if(soc >= SOC_EXYNOS_3475 && soc <= SOC_EXYNOS_880) return SOC_VENDOR_EXYNOS;
|
||||
else if(soc >= SOC_MTK_MT6893 && soc <= SOC_MTK_MT8783) return SOC_VENDOR_MEDIATEK;
|
||||
else if(soc >= SOC_SNAPD_QSD8650 && soc <= SOC_SNAPD_SM8650_AB) return SOC_VENDOR_SNAPDRAGON;
|
||||
else if(soc >= SOC_APPLE_M1 && soc <= SOC_APPLE_M3_MAX) return SOC_VENDOR_APPLE;
|
||||
else if(soc >= SOC_ALLWINNER_A10 && soc <= SOC_ALLWINNER_R328) return SOC_VENDOR_ALLWINNER;
|
||||
else if(soc >= SOC_ROCKCHIP_3288 && soc <= SOC_ROCKCHIP_3588) return SOC_VENDOR_ROCKCHIP;
|
||||
else if(soc >= SOC_GOOGLE_TENSOR && soc <= SOC_GOOGLE_TENSOR_G3) return SOC_VENDOR_GOOGLE;
|
||||
else if(soc >= SOC_TEGRA_X1 && soc <= SOC_TEGRA_X1) return SOC_VENDOR_NVIDIA;
|
||||
else if(soc >= SOC_AMPERE_ALTRA && soc <= SOC_AMPERE_ALTRA) return SOC_VENDOR_AMPERE;
|
||||
else if(soc >= SOC_NXP_IMX8QM && soc <= SOC_NXP_IMX93) return SOC_VENDOR_NXP;
|
||||
else if(soc >= SOC_AMLOGIC_A311D && soc <= SOC_AMLOGIC_A311D) return SOC_VENDOR_AMLOGIC;
|
||||
else if(soc >= SOC_MTK_MT6889 && soc <= SOC_MTK_MT8783) return SOC_VENDOR_MEDIATEK;
|
||||
else if(soc >= SOC_SNAPD_QSD8650 && soc <= SOC_SNAPD_SM8350) return SOC_VENDOR_SNAPDRAGON;
|
||||
return SOC_VENDOR_UNKNOWN;
|
||||
}
|
||||
|
||||
|
||||
@@ -1,15 +0,0 @@
|
||||
#include <stdint.h>
|
||||
#include "../common/global.h"
|
||||
|
||||
// https://learn.arm.com/learning-paths/servers-and-cloud-computing/sve/sve_basics/#:~:text=Using%20a%20text%20editor%20of%20your%20choice%2C%20copy,svcntb%28%29%29%3B%20%7D%20This%20program%20prints%20the%20vector%20length
|
||||
uint64_t sve_cntb(void) {
|
||||
#ifdef __ARM_FEATURE_SVE
|
||||
uint64_t x0 = 0;
|
||||
__asm volatile("cntb %0"
|
||||
: "=r"(x0));
|
||||
return x0;
|
||||
#else
|
||||
printWarn("sve_cntb: Hardware supports SVE, but it was not enabled by the compiler");
|
||||
return 0;
|
||||
#endif
|
||||
}
|
||||
@@ -1,6 +0,0 @@
|
||||
#ifndef __SVE_DETECTION__
|
||||
#define __SVE_DETECTION__
|
||||
|
||||
uint64_t sve_cntb(void);
|
||||
|
||||
#endif
|
||||
271
src/arm/uarch.c
271
src/arm/uarch.c
@@ -7,9 +7,12 @@
|
||||
#include "uarch.h"
|
||||
#include "../common/global.h"
|
||||
|
||||
#define STRING_UNKNOWN "Unknown"
|
||||
|
||||
// Data not available
|
||||
#define NA -1
|
||||
|
||||
typedef uint32_t MICROARCH;
|
||||
typedef uint32_t ISA;
|
||||
|
||||
struct uarch {
|
||||
@@ -21,28 +24,80 @@ struct uarch {
|
||||
};
|
||||
|
||||
enum {
|
||||
ISA_ARMv6,
|
||||
ISA_ARMv6_T2,
|
||||
ISA_ARMv6_KZ,
|
||||
ISA_ARMv6_K,
|
||||
ISA_ARMv7_A,
|
||||
ISA_ARMv8_A,
|
||||
ISA_ARMv8_A_AArch32,
|
||||
ISA_ARMv8_1_A,
|
||||
ISA_ARMv8_2_A,
|
||||
ISA_ARMv8_3_A,
|
||||
ISA_ARMv8_4_A,
|
||||
ISA_ARMv8_5_A,
|
||||
ISA_ARMv8_6_A,
|
||||
ISA_ARMv9_A,
|
||||
ISA_ARMv9_2_A
|
||||
};
|
||||
|
||||
enum {
|
||||
UARCH_UNKNOWN,
|
||||
// ARM
|
||||
UARCH_ARM7,
|
||||
UARCH_ARM9,
|
||||
UARCH_ARM11, // ARM 1136, ARM 1156, ARM 1176, or ARM 11MPCore.
|
||||
UARCH_CORTEX_A5,
|
||||
UARCH_CORTEX_A7,
|
||||
UARCH_CORTEX_A8,
|
||||
UARCH_CORTEX_A9,
|
||||
UARCH_CORTEX_A12,
|
||||
UARCH_CORTEX_A15,
|
||||
UARCH_CORTEX_A17,
|
||||
UARCH_CORTEX_A32,
|
||||
UARCH_CORTEX_A35,
|
||||
UARCH_CORTEX_A53,
|
||||
UARCH_CORTEX_A55r0, // ARM Cortex-A55 revision 0 (restricted dual-issue capabilities compared to revision 1+).
|
||||
UARCH_CORTEX_A55,
|
||||
UARCH_CORTEX_A57,
|
||||
UARCH_CORTEX_A65,
|
||||
UARCH_CORTEX_A72,
|
||||
UARCH_CORTEX_A73,
|
||||
UARCH_CORTEX_A75,
|
||||
UARCH_CORTEX_A76,
|
||||
UARCH_CORTEX_A77,
|
||||
UARCH_CORTEX_A78,
|
||||
UARCH_NEOVERSE_N1,
|
||||
UARCH_NEOVERSE_E1,
|
||||
UARCH_SCORPION,
|
||||
UARCH_KRAIT,
|
||||
UARCH_KYRO,
|
||||
UARCH_FALKOR,
|
||||
UARCH_SAPHIRA,
|
||||
UARCH_DENVER,
|
||||
UARCH_DENVER2,
|
||||
UARCH_CARMEL,
|
||||
// SAMSUNG
|
||||
UARCH_EXYNOS_M1, // Samsung Exynos M1 (Exynos 8890 big cores)
|
||||
UARCH_EXYNOS_M2, // Samsung Exynos M2 (Exynos 8895 big cores)
|
||||
UARCH_EXYNOS_M3, // Samsung Exynos M3 (Exynos 9810 big cores)
|
||||
UARCH_EXYNOS_M4, // Samsung Exynos M4 (Exynos 9820 big cores)
|
||||
UARCH_EXYNOS_M5, // Samsung Exynos M5 (Exynos 9830 big cores)
|
||||
// APPLE
|
||||
UARCH_SWIFT, // Apple A6 and A6X processors.
|
||||
UARCH_CYCLONE, // Apple A7 processor.
|
||||
UARCH_TYPHOON, // Apple A8 and A8X processor
|
||||
UARCH_TWISTER, // Apple A9 and A9X processor.
|
||||
UARCH_HURRICANE, // Apple A10 and A10X processor.
|
||||
UARCH_MONSOON, // Apple A11 processor (big cores).
|
||||
UARCH_MISTRAL, // Apple A11 processor (little cores).
|
||||
UARCH_VORTEX, // Apple A12 processor (big cores).
|
||||
UARCH_TEMPEST, // Apple A12 processor (big cores).
|
||||
UARCH_LIGHTNING, // Apple A13 processor (big cores).
|
||||
UARCH_THUNDER, // Apple A13 processor (little cores).
|
||||
// CAVIUM
|
||||
UARCH_THUNDERX, // Cavium ThunderX
|
||||
UARCH_THUNDERX2, // Cavium ThunderX2 (originally Broadcom Vulkan).
|
||||
// MARVELL
|
||||
UARCH_PJ4,
|
||||
UARCH_BRAHMA_B15,
|
||||
UARCH_BRAHMA_B53,
|
||||
UARCH_XGENE, // Applied Micro X-Gene.
|
||||
UARCH_TAISHAN_V110 // HiSilicon TaiShan v110 (Huawei Kunpeng 920 series processors).
|
||||
};
|
||||
|
||||
static const ISA isas_uarch[] = {
|
||||
[UARCH_ARM1136] = ISA_ARMv6,
|
||||
[UARCH_ARM1156] = ISA_ARMv6_T2,
|
||||
[UARCH_ARM1176] = ISA_ARMv6_KZ,
|
||||
[UARCH_ARM11MPCORE] = ISA_ARMv6_K,
|
||||
[UARCH_CORTEX_A5] = ISA_ARMv7_A,
|
||||
[UARCH_CORTEX_A7] = ISA_ARMv7_A,
|
||||
[UARCH_CORTEX_A8] = ISA_ARMv7_A,
|
||||
@@ -63,33 +118,13 @@ static const ISA isas_uarch[] = {
|
||||
[UARCH_CORTEX_A76] = ISA_ARMv8_2_A,
|
||||
[UARCH_CORTEX_A77] = ISA_ARMv8_2_A,
|
||||
[UARCH_CORTEX_A78] = ISA_ARMv8_2_A,
|
||||
[UARCH_CORTEX_A78C] = ISA_ARMv8_2_A,
|
||||
[UARCH_CORTEX_A78AE] = ISA_ARMv8_2_A,
|
||||
[UARCH_CORTEX_A510] = ISA_ARMv9_A,
|
||||
[UARCH_CORTEX_A520] = ISA_ARMv9_2_A,
|
||||
[UARCH_CORTEX_A710] = ISA_ARMv9_A,
|
||||
[UARCH_CORTEX_A715] = ISA_ARMv9_A,
|
||||
[UARCH_CORTEX_A720] = ISA_ARMv9_2_A,
|
||||
[UARCH_CORTEX_A725] = ISA_ARMv9_2_A,
|
||||
[UARCH_CORTEX_X1] = ISA_ARMv8_2_A,
|
||||
[UARCH_CORTEX_X1C] = ISA_ARMv8_2_A, // Assuming same as X1
|
||||
[UARCH_CORTEX_X2] = ISA_ARMv9_A,
|
||||
[UARCH_CORTEX_X3] = ISA_ARMv9_A,
|
||||
[UARCH_CORTEX_X4] = ISA_ARMv9_2_A,
|
||||
[UARCH_CORTEX_X925] = ISA_ARMv9_2_A,
|
||||
[UARCH_NEOVERSE_N1] = ISA_ARMv8_2_A,
|
||||
[UARCH_NEOVERSE_N2] = ISA_ARMv9_A,
|
||||
[UARCH_NEOVERSE_E1] = ISA_ARMv8_2_A,
|
||||
[UARCH_NEOVERSE_V1] = ISA_ARMv8_4_A,
|
||||
[UARCH_NEOVERSE_V2] = ISA_ARMv9_A,
|
||||
[UARCH_NEOVERSE_V3] = ISA_ARMv9_2_A,
|
||||
[UARCH_BRAHMA_B15] = ISA_ARMv7_A, // Same as Cortex-A15
|
||||
[UARCH_BRAHMA_B53] = ISA_ARMv8_A, // Same as Cortex-A53
|
||||
[UARCH_THUNDERX] = ISA_ARMv8_A,
|
||||
[UARCH_THUNDERX2] = ISA_ARMv8_1_A,
|
||||
[UARCH_TAISHAN_V110] = ISA_ARMv8_2_A,
|
||||
[UARCH_TAISHAN_V120] = ISA_ARMv8_2_A, // Not confirmed
|
||||
[UARCH_TAISHAN_V200] = ISA_ARMv8_2_A, // Not confirmed
|
||||
[UARCH_DENVER] = ISA_ARMv8_A,
|
||||
[UARCH_DENVER2] = ISA_ARMv8_A,
|
||||
[UARCH_CARMEL] = ISA_ARMv8_A,
|
||||
@@ -104,62 +139,44 @@ static const ISA isas_uarch[] = {
|
||||
[UARCH_EXYNOS_M3] = ISA_ARMv8_A,
|
||||
[UARCH_EXYNOS_M4] = ISA_ARMv8_2_A,
|
||||
[UARCH_EXYNOS_M5] = ISA_ARMv8_2_A,
|
||||
[UARCH_ICESTORM] = ISA_ARMv8_5_A, // https://github.com/llvm/llvm-project/blob/main/llvm/include/llvm/Support/AArch64TargetParser.def
|
||||
[UARCH_FIRESTORM] = ISA_ARMv8_5_A,
|
||||
[UARCH_BLIZZARD] = ISA_ARMv8_6_A, // https://github.com/llvm/llvm-project/blob/main/llvm/unittests/TargetParser/TargetParserTest.cpp
|
||||
[UARCH_AVALANCHE] = ISA_ARMv8_6_A, // https://github.com/llvm/llvm-project/blob/main/llvm/unittests/TargetParser/TargetParserTest.cpp
|
||||
[UARCH_SAWTOOTH] = ISA_ARMv8_6_A, // https://github.com/llvm/llvm-project/blob/main/llvm/unittests/TargetParser/TargetParserTest.cpp
|
||||
[UARCH_EVEREST] = ISA_ARMv8_6_A, // https://github.com/llvm/llvm-project/blob/main/llvm/unittests/TargetParser/TargetParserTest.cpp
|
||||
[UARCH_PJ4] = ISA_ARMv7_A,
|
||||
[UARCH_XIAOMI] = ISA_ARMv8_A,
|
||||
};
|
||||
|
||||
static char* isas_string[] = {
|
||||
[ISA_ARMv6] = "ARMv6",
|
||||
[ISA_ARMv6_T2] = "ARMv6T2",
|
||||
[ISA_ARMv6_KZ] = "ARMv6KZ",
|
||||
[ISA_ARMv6_K] = "ARMv6K",
|
||||
[ISA_ARMv7_A] = "ARMv7",
|
||||
[ISA_ARMv8_A] = "ARMv8",
|
||||
[ISA_ARMv8_A_AArch32] = "ARMv8 AArch32",
|
||||
[ISA_ARMv8_1_A] = "ARMv8.1",
|
||||
[ISA_ARMv8_2_A] = "ARMv8.2",
|
||||
[ISA_ARMv8_3_A] = "ARMv8.3",
|
||||
[ISA_ARMv8_4_A] = "ARMv8.4",
|
||||
[ISA_ARMv8_5_A] = "ARMv8.5",
|
||||
[ISA_ARMv8_6_A] = "ARMv8.6",
|
||||
[ISA_ARMv9_A] = "ARMv9",
|
||||
[ISA_ARMv9_2_A] = "ARMv9.2",
|
||||
};
|
||||
|
||||
#define UARCH_START if (false) {}
|
||||
#define CHECK_UARCH(arch, cpu, im_, p_, v_, r_, str, uarch, vendor) \
|
||||
else if (im_ == im && p_ == p && (v_ == NA || v_ == v) && (r_ == NA || r_ == r)) fill_uarch(arch, cpu, str, uarch, vendor);
|
||||
#define UARCH_END else { printBugCheckRelease("Unknown microarchitecture detected: IM=0x%X P=0x%X V=0x%X R=0x%X", im, p, v, r); \
|
||||
fill_uarch(arch, cpu, "Unknown", UARCH_UNKNOWN, CPU_VENDOR_UNKNOWN); }
|
||||
#define UARCH_END else { printBug("Unknown microarchitecture detected: IM=0x%.8X P=0x%.8X V=0x%.8X R=0x%.8X", im, p, v, r); fill_uarch(arch, cpu, "Unknown", UARCH_UNKNOWN, CPU_VENDOR_UNKNOWN); }
|
||||
|
||||
void fill_uarch(struct uarch* arch, struct cpuInfo* cpu, char* str, MICROARCH u, VENDOR vendor) {
|
||||
arch->uarch = u;
|
||||
arch->isa = isas_uarch[arch->uarch];
|
||||
cpu->cpu_vendor = vendor;
|
||||
|
||||
arch->uarch_str = emalloc(sizeof(char) * (strlen(str)+1));
|
||||
arch->uarch_str = malloc(sizeof(char) * (strlen(str)+1));
|
||||
strcpy(arch->uarch_str, str);
|
||||
|
||||
arch->isa_str = emalloc(sizeof(char) * (strlen(isas_string[arch->isa])+1));
|
||||
arch->isa_str = malloc(sizeof(char) * (strlen(isas_string[arch->isa])+1));
|
||||
strcpy(arch->isa_str, isas_string[arch->isa]);
|
||||
}
|
||||
|
||||
/*
|
||||
* Codes are based on pytorch/cpuinfo, more precisely:
|
||||
* - https://github.com/pytorch/cpuinfo/blob/main/src/arm/uarch.c
|
||||
* - https://github.com/pytorch/cpuinfo/blob/master/src/arm/uarch.c
|
||||
* Other sources:
|
||||
* - https://elixir.bootlin.com/linux/latest/source/arch/arm64/include/asm/cputype.h
|
||||
* - https://elixir.bootlin.com/linux/latest/source/arch/arm/include/asm/cputype.h
|
||||
* - https://github.com/AsahiLinux/m1n1/blob/main/src/chickens.c
|
||||
*/
|
||||
struct uarch* get_uarch_from_midr(uint32_t midr, struct cpuInfo* cpu) {
|
||||
struct uarch* arch = emalloc(sizeof(struct uarch));
|
||||
struct uarch* arch = malloc(sizeof(struct uarch));
|
||||
uint32_t im = midr_get_implementer(midr);
|
||||
uint32_t p = midr_get_part(midr);
|
||||
uint32_t v = midr_get_variant(midr);
|
||||
@@ -173,10 +190,6 @@ struct uarch* get_uarch_from_midr(uint32_t midr, struct cpuInfo* cpu) {
|
||||
// ----------------------------------------------------------------------- //
|
||||
// IM P V R //
|
||||
UARCH_START
|
||||
CHECK_UARCH(arch, cpu, 'A', 0xB36, NA, NA, "ARM1136", UARCH_ARM1136, CPU_VENDOR_ARM)
|
||||
CHECK_UARCH(arch, cpu, 'A', 0xB56, NA, NA, "ARM1156", UARCH_ARM1156, CPU_VENDOR_ARM)
|
||||
CHECK_UARCH(arch, cpu, 'A', 0xB76, NA, NA, "ARM1176", UARCH_ARM1176, CPU_VENDOR_ARM)
|
||||
CHECK_UARCH(arch, cpu, 'A', 0xB02, NA, NA, "ARM11 MPCore", UARCH_ARM11MPCORE, CPU_VENDOR_ARM)
|
||||
CHECK_UARCH(arch, cpu, 'A', 0xC05, NA, NA, "Cortex-A5", UARCH_CORTEX_A5, CPU_VENDOR_ARM)
|
||||
CHECK_UARCH(arch, cpu, 'A', 0xC07, NA, NA, "Cortex-A7", UARCH_CORTEX_A7, CPU_VENDOR_ARM)
|
||||
CHECK_UARCH(arch, cpu, 'A', 0xC08, NA, NA, "Cortex-A8", UARCH_CORTEX_A8, CPU_VENDOR_ARM)
|
||||
@@ -199,26 +212,8 @@ struct uarch* get_uarch_from_midr(uint32_t midr, struct cpuInfo* cpu) {
|
||||
CHECK_UARCH(arch, cpu, 'A', 0xD0C, NA, NA, "Neoverse N1", UARCH_NEOVERSE_N1, CPU_VENDOR_ARM)
|
||||
CHECK_UARCH(arch, cpu, 'A', 0xD0D, NA, NA, "Cortex-A77", UARCH_CORTEX_A77, CPU_VENDOR_ARM)
|
||||
CHECK_UARCH(arch, cpu, 'A', 0xD0E, NA, NA, "Cortex-A76", UARCH_CORTEX_A76, CPU_VENDOR_ARM)
|
||||
CHECK_UARCH(arch, cpu, 'A', 0xD40, NA, NA, "Neoverse V1", UARCH_NEOVERSE_V1, CPU_VENDOR_ARM)
|
||||
CHECK_UARCH(arch, cpu, 'A', 0xD41, NA, NA, "Cortex-A78", UARCH_CORTEX_A78, CPU_VENDOR_ARM)
|
||||
CHECK_UARCH(arch, cpu, 'A', 0xD42, NA, NA, "Cortex-A78AE", UARCH_CORTEX_A78AE, CPU_VENDOR_ARM)
|
||||
CHECK_UARCH(arch, cpu, 'A', 0xD44, NA, NA, "Cortex-X1", UARCH_CORTEX_X1, CPU_VENDOR_ARM)
|
||||
CHECK_UARCH(arch, cpu, 'A', 0xD46, NA, NA, "Cortex‑A510", UARCH_CORTEX_A510, CPU_VENDOR_ARM)
|
||||
CHECK_UARCH(arch, cpu, 'A', 0xD47, NA, NA, "Cortex‑A710", UARCH_CORTEX_A710, CPU_VENDOR_ARM)
|
||||
CHECK_UARCH(arch, cpu, 'A', 0xD48, NA, NA, "Cortex-X2", UARCH_CORTEX_X2, CPU_VENDOR_ARM)
|
||||
CHECK_UARCH(arch, cpu, 'A', 0xD49, NA, NA, "Neoverse N2", UARCH_NEOVERSE_N2, CPU_VENDOR_ARM)
|
||||
CHECK_UARCH(arch, cpu, 'A', 0xD4A, NA, NA, "Neoverse E1", UARCH_NEOVERSE_E1, CPU_VENDOR_ARM)
|
||||
CHECK_UARCH(arch, cpu, 'A', 0xD4B, NA, NA, "Cortex-A78C", UARCH_CORTEX_A78C, CPU_VENDOR_ARM)
|
||||
CHECK_UARCH(arch, cpu, 'A', 0xD4C, NA, NA, "Cortex-X1C", UARCH_CORTEX_X1C, CPU_VENDOR_ARM)
|
||||
CHECK_UARCH(arch, cpu, 'A', 0xD4D, NA, NA, "Cortex-A715", UARCH_CORTEX_A715, CPU_VENDOR_ARM)
|
||||
CHECK_UARCH(arch, cpu, 'A', 0xD4E, NA, NA, "Cortex-X3", UARCH_CORTEX_X3, CPU_VENDOR_ARM)
|
||||
CHECK_UARCH(arch, cpu, 'A', 0xD4F, NA, NA, "Neoverse V2", UARCH_NEOVERSE_V2, CPU_VENDOR_ARM)
|
||||
CHECK_UARCH(arch, cpu, 'A', 0xD80, NA, NA, "Cortex-A520", UARCH_CORTEX_A520, CPU_VENDOR_ARM)
|
||||
CHECK_UARCH(arch, cpu, 'A', 0xD81, NA, NA, "Cortex-A720", UARCH_CORTEX_A720, CPU_VENDOR_ARM)
|
||||
CHECK_UARCH(arch, cpu, 'A', 0xD82, NA, NA, "Cortex-X4", UARCH_CORTEX_X4, CPU_VENDOR_ARM)
|
||||
CHECK_UARCH(arch, cpu, 'A', 0xD84, NA, NA, "Neoverse V3", UARCH_NEOVERSE_V3, CPU_VENDOR_ARM)
|
||||
CHECK_UARCH(arch, cpu, 'A', 0xD85, NA, NA, "Cortex-X925", UARCH_CORTEX_X925, CPU_VENDOR_ARM)
|
||||
CHECK_UARCH(arch, cpu, 'A', 0xD87, NA, NA, "Cortex-A725", UARCH_CORTEX_A725, CPU_VENDOR_ARM)
|
||||
|
||||
CHECK_UARCH(arch, cpu, 'B', 0x00F, NA, NA, "Brahma B15", UARCH_BRAHMA_B15, CPU_VENDOR_BROADCOM)
|
||||
CHECK_UARCH(arch, cpu, 'B', 0x100, NA, NA, "Brahma B53", UARCH_BRAHMA_B53, CPU_VENDOR_BROADCOM)
|
||||
@@ -230,11 +225,8 @@ struct uarch* get_uarch_from_midr(uint32_t midr, struct cpuInfo* cpu) {
|
||||
CHECK_UARCH(arch, cpu, 'C', 0x0A3, NA, NA, "ThunderX 81XX", UARCH_THUNDERX, CPU_VENDOR_CAVIUM)
|
||||
CHECK_UARCH(arch, cpu, 'C', 0x0AF, NA, NA, "ThunderX2 99XX", UARCH_THUNDERX2, CPU_VENDOR_CAVIUM)
|
||||
|
||||
CHECK_UARCH(arch, cpu, 'H', 0xD01, NA, NA, "TaiShan v110", UARCH_TAISHAN_V110, CPU_VENDOR_HUAWEI) // Kunpeng 920 series
|
||||
CHECK_UARCH(arch, cpu, 'H', 0xD02, 2, 2, "TaiShan v120", UARCH_TAISHAN_V120, CPU_VENDOR_HUAWEI) // Kiring 9000S Big cores (https://github.com/Dr-Noob/cpufetch/issues/259)
|
||||
CHECK_UARCH(arch, cpu, 'H', 0xD02, NA, NA, "TaiShan v200", UARCH_TAISHAN_V200, CPU_VENDOR_HUAWEI) // Kunpeng 930 series (found in openeuler: https://mailweb.openeuler.org/hyperkitty/list/kernel@openeuler.org/message/XQCV7NX2UKRIUWUFKRF4PO3QENCOUFR3)
|
||||
CHECK_UARCH(arch, cpu, 'H', 0xD01, NA, NA, "TaiShan v110", UARCH_TAISHAN_V110, CPU_VENDOR_HUAWUEI) // Kunpeng 920 series
|
||||
CHECK_UARCH(arch, cpu, 'H', 0xD40, NA, NA, "Cortex-A76", UARCH_CORTEX_A76, CPU_VENDOR_ARM) // Kirin 980 Big/Medium cores -> Cortex-A76
|
||||
CHECK_UARCH(arch, cpu, 'H', 0xD42, NA, NA, "TaiShan v120", UARCH_TAISHAN_V120, CPU_VENDOR_HUAWEI) // Kiring 9000S Small Cores (https://github.com/Dr-Noob/cpufetch/issues/259)
|
||||
|
||||
CHECK_UARCH(arch, cpu, 'N', 0x000, NA, NA, "Denver", UARCH_DENVER, CPU_VENDOR_NVIDIA)
|
||||
CHECK_UARCH(arch, cpu, 'N', 0x003, NA, NA, "Denver2", UARCH_DENVER2, CPU_VENDOR_NVIDIA)
|
||||
@@ -271,18 +263,6 @@ struct uarch* get_uarch_from_midr(uint32_t midr, struct cpuInfo* cpu) {
|
||||
CHECK_UARCH(arch, cpu, 'S', 0x003, 1, NA, "Exynos M4", UARCH_EXYNOS_M4, CPU_VENDOR_SAMSUNG) // Exynos 9820
|
||||
CHECK_UARCH(arch, cpu, 'S', 0x004, 1, NA, "Exynos M5", UARCH_EXYNOS_M5, CPU_VENDOR_SAMSUNG) // Exynos 9820 (this one looks wrong at uarch.c ...)
|
||||
|
||||
CHECK_UARCH(arch, cpu, 'p', 0x663, 1, NA, "Xiaomi", UARCH_XIAOMI, CPU_VENDOR_PHYTIUM) // From a fellow contributor (https://github.com/Dr-Noob/cpufetch/issues/125)
|
||||
// Also interesting: https://en.wikipedia.org/wiki/FeiTeng_(processor)
|
||||
|
||||
CHECK_UARCH(arch, cpu, 'a', 0x022, NA, NA, "Icestorm", UARCH_ICESTORM, CPU_VENDOR_APPLE)
|
||||
CHECK_UARCH(arch, cpu, 'a', 0x023, NA, NA, "Firestorm", UARCH_FIRESTORM, CPU_VENDOR_APPLE)
|
||||
CHECK_UARCH(arch, cpu, 'a', 0x024, NA, NA, "Icestorm", UARCH_ICESTORM, CPU_VENDOR_APPLE) // https://github.com/Dr-Noob/cpufetch/issues/263
|
||||
CHECK_UARCH(arch, cpu, 'a', 0x025, NA, NA, "Firestorm", UARCH_FIRESTORM, CPU_VENDOR_APPLE) // https://github.com/Dr-Noob/cpufetch/issues/263
|
||||
CHECK_UARCH(arch, cpu, 'a', 0x030, NA, NA, "Blizzard", UARCH_BLIZZARD, CPU_VENDOR_APPLE)
|
||||
CHECK_UARCH(arch, cpu, 'a', 0x031, NA, NA, "Avalanche", UARCH_AVALANCHE, CPU_VENDOR_APPLE)
|
||||
CHECK_UARCH(arch, cpu, 'a', 0x048, NA, NA, "Sawtooth", UARCH_SAWTOOTH, CPU_VENDOR_APPLE)
|
||||
CHECK_UARCH(arch, cpu, 'a', 0x049, NA, NA, "Everest", UARCH_EVEREST, CPU_VENDOR_APPLE)
|
||||
|
||||
CHECK_UARCH(arch, cpu, 'V', 0x581, NA, NA, "PJ4", UARCH_PJ4, CPU_VENDOR_MARVELL)
|
||||
CHECK_UARCH(arch, cpu, 'V', 0x584, NA, NA, "PJ4B-MP", UARCH_PJ4, CPU_VENDOR_MARVELL)
|
||||
|
||||
@@ -291,113 +271,12 @@ struct uarch* get_uarch_from_midr(uint32_t midr, struct cpuInfo* cpu) {
|
||||
return arch;
|
||||
}
|
||||
|
||||
bool is_ARMv8_or_newer(struct cpuInfo* cpu) {
|
||||
return cpu->arch->isa >= ISA_ARMv8_A;
|
||||
}
|
||||
|
||||
bool has_fma_support(struct cpuInfo* cpu) {
|
||||
// Arm A64 Instruction Set Architecture
|
||||
// https://developer.arm.com/documentation/ddi0596/2021-12/SIMD-FP-Instructions
|
||||
return is_ARMv8_or_newer(cpu);
|
||||
}
|
||||
|
||||
int get_vpus_width(struct cpuInfo* cpu) {
|
||||
// If the CPU has NEON, width can be 64 or 128 [1].
|
||||
// In >= ARMv8, NEON are 128 bits width [2]
|
||||
// If the CPU has SVE/SVE2, width can be between 128-2048 [3],
|
||||
// so we get the exact value from cntb [4]
|
||||
//
|
||||
// [1] https://en.wikipedia.org/wiki/ARM_architecture_family#Advanced_SIMD_(Neon)
|
||||
// [2] https://developer.arm.com/documentation/102474/0100/Fundamentals-of-Armv8-Neon-technology
|
||||
// [3] https://www.anandtech.com/show/16640/arm-announces-neoverse-v1-n2-platforms-cpus-cmn700-mesh/5
|
||||
// [4] https://developer.arm.com/documentation/ddi0596/2020-12/SVE-Instructions/CNTB--CNTD--CNTH--CNTW--Set-scalar-to-multiple-of-predicate-constraint-element-count-
|
||||
|
||||
if (cpu->feat->SVE && cpu->feat->cntb > 0) {
|
||||
return cpu->feat->cntb * 8;
|
||||
}
|
||||
else if (cpu->feat->NEON) {
|
||||
if(is_ARMv8_or_newer(cpu)) {
|
||||
return 128;
|
||||
}
|
||||
else {
|
||||
return 64;
|
||||
}
|
||||
}
|
||||
else {
|
||||
return 32;
|
||||
}
|
||||
}
|
||||
|
||||
int get_number_of_vpus(struct cpuInfo* cpu) {
|
||||
MICROARCH ua = cpu->arch->uarch;
|
||||
|
||||
switch(ua) {
|
||||
case UARCH_CORTEX_X925: // [https://www.anandtech.com/show/21399/arm-unveils-2024-cpu-core-designs-cortex-x925-a725-and-a520-arm-v9-2-redefined-for-3nm-/2]
|
||||
return 6;
|
||||
case UARCH_EVEREST: // Just a guess, needs confirmation.
|
||||
case UARCH_FIRESTORM: // [https://dougallj.github.io/applecpu/firestorm-simd.html]
|
||||
case UARCH_AVALANCHE: // [https://en.wikipedia.org/wiki/Comparison_of_ARM_processors]
|
||||
case UARCH_CORTEX_X1: // [https://www.anandtech.com/show/15813/arm-cortex-a78-cortex-x1-cpu-ip-diverging/3]
|
||||
case UARCH_CORTEX_X1C: // Assuming same as X1
|
||||
case UARCH_CORTEX_X2: // [https://www.anandtech.com/show/16693/arm-announces-mobile-armv9-cpu-microarchitectures-cortexx2-cortexa710-cortexa510/2]
|
||||
case UARCH_CORTEX_X3: // [https://www.hwcooling.net/en/cortex-x3-the-new-fastest-arm-core-architecture-analysis: "The FPU and SIMD unit of the core still has four pipelines"]
|
||||
case UARCH_CORTEX_X4: // [https://www.anandtech.com/show/18871/arm-unveils-armv92-mobile-architecture-cortex-x4-a720-and-a520-64bit-exclusive/2]: "Cortex-X4: Out-of-Order Core"
|
||||
case UARCH_NEOVERSE_V1: // [https://en.wikichip.org/wiki/arm_holdings/microarchitectures/neoverse_v1]
|
||||
case UARCH_NEOVERSE_V2: // [https://chipsandcheese.com/2023/09/11/hot-chips-2023-arms-neoverse-v2/]
|
||||
case UARCH_NEOVERSE_V3: // Assuming same as V2
|
||||
return 4;
|
||||
case UARCH_SAWTOOTH: // Needs confirmation, rn this is the best we know: https://mastodon.social/@dougall/111118317031041336
|
||||
case UARCH_EXYNOS_M3: // [https://www.anandtech.com/show/12361/samsung-exynos-m3-architecture]
|
||||
case UARCH_EXYNOS_M4: // [https://en.wikichip.org/wiki/samsung/microarchitectures/m4#Block_Diagram]
|
||||
case UARCH_EXYNOS_M5: // [https://en.wikichip.org/wiki/samsung/microarchitectures/m5]
|
||||
return 3;
|
||||
case UARCH_ICESTORM: // [https://dougallj.github.io/applecpu/icestorm-simd.html]
|
||||
case UARCH_BLIZZARD: // [https://en.wikipedia.org/wiki/Comparison_of_ARM_processors]
|
||||
case UARCH_TAISHAN_V110:// [https://www-file.huawei.com/-/media/corp2020/pdf/publications/huawei-research/2022/huawei-research-issue1-en.pdf]: "128-bit x 2 for single precision"
|
||||
case UARCH_TAISHAN_V120:// Not confirmed, asssuming same as v110
|
||||
case UARCH_TAISHAN_V200:// Not confirmed, asssuming same as v110
|
||||
case UARCH_CORTEX_A57: // [https://www.anandtech.com/show/8718/the-samsung-galaxy-note-4-exynos-review/5]
|
||||
case UARCH_CORTEX_A72: // [https://www.anandtech.com/show/10347/arm-cortex-a73-artemis-unveiled/2]
|
||||
case UARCH_CORTEX_A73: // [https://www.anandtech.com/show/10347/arm-cortex-a73-artemis-unveiled/2]
|
||||
case UARCH_CORTEX_A75: // [https://www.anandtech.com/show/11441/dynamiq-and-arms-new-cpus-cortex-a75-a55/3]
|
||||
case UARCH_CORTEX_A76: // [https://www.anandtech.com/show/12785/arm-cortex-a76-cpu-unveiled-7nm-powerhouse/3]
|
||||
case UARCH_CORTEX_A77: // [https://fuse.wikichip.org/news/2339/arm-unveils-cortex-a77-emphasizes-single-thread-performance]
|
||||
case UARCH_CORTEX_A78: // [https://fuse.wikichip.org/news/3536/arm-unveils-the-cortex-a78-when-less-is-more]
|
||||
case UARCH_CORTEX_A78C: // Assuming same as A78
|
||||
case UARCH_CORTEX_A78AE:// Assuming same as A78
|
||||
case UARCH_EXYNOS_M1: // [https://www.anandtech.com/show/12361/samsung-exynos-m3-architecture]
|
||||
case UARCH_EXYNOS_M2: // [https://www.anandtech.com/show/12361/samsung-exynos-m3-architecture]
|
||||
case UARCH_NEOVERSE_N1: // [https://en.wikichip.org/wiki/arm_holdings/microarchitectures/neoverse_n1#Individual_Core]
|
||||
case UARCH_NEOVERSE_N2: // [https://chipsandcheese.com/2023/08/18/arms-neoverse-n2-cortex-a710-for-servers/]
|
||||
case UARCH_CORTEX_A710: // [https://chipsandcheese.com/2023/08/11/arms-cortex-a710-winning-by-default/]: Fig in Core Overview. Table in Instruction Scheduling and Execution
|
||||
case UARCH_CORTEX_A715: // [https://www.hwcooling.net/en/arm-introduces-new-cortex-a715-core-architecture-analysis/]: "the numbers of ALU and FPU execution units themselves >
|
||||
case UARCH_CORTEX_A720: // Assuming same as A715: https://www.anandtech.com/show/18871/arm-unveils-armv92-mobile-architecture-cortex-x4-a720-and-a520-64bit-exclusive/3
|
||||
case UARCH_CORTEX_A725: // Assuming same as A720
|
||||
return 2;
|
||||
case UARCH_NEOVERSE_E1: // [https://www.anandtech.com/show/13959/arm-announces-neoverse-n1-platform/5]
|
||||
// A510 is integrated as part of a Complex. Normally, each complex would incorporate two Cortex-A510 cores.
|
||||
// Each complex incorporates a single VPU with 2 ports, so for each A510 there is theoretically 1 port.
|
||||
case UARCH_CORTEX_A510: // [https://en.wikichip.org/wiki/arm_holdings/microarchitectures/cortex-a510#Vector_Processing_Unit_.28VPU.29]
|
||||
case UARCH_CORTEX_A520: // Assuming same as A50: https://www.anandtech.com/show/18871/arm-unveils-armv92-mobile-architecture-cortex-x4-a720-and-a520-64bit-exclusive/4
|
||||
return 1;
|
||||
default:
|
||||
// ARMv6
|
||||
// ARMv7
|
||||
// Remaining UARCH_CORTEX_AXX
|
||||
// Old Snapdragon (e.g., Scorpion, Krait, etc)
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
|
||||
char* get_str_uarch(struct cpuInfo* cpu) {
|
||||
return cpu->arch->uarch_str;
|
||||
}
|
||||
|
||||
MICROARCH get_uarch(struct uarch* arch) {
|
||||
return arch->uarch;
|
||||
}
|
||||
|
||||
void free_uarch_struct(struct uarch* arch) {
|
||||
free(arch->uarch_str);
|
||||
free(arch);
|
||||
}
|
||||
|
||||
|
||||
103
src/arm/uarch.h
103
src/arm/uarch.h
@@ -5,111 +5,8 @@
|
||||
|
||||
#include "midr.h"
|
||||
|
||||
enum {
|
||||
UARCH_UNKNOWN,
|
||||
// ARM
|
||||
UARCH_ARM7,
|
||||
UARCH_ARM9,
|
||||
UARCH_ARM1136,
|
||||
UARCH_ARM1156,
|
||||
UARCH_ARM1176,
|
||||
UARCH_ARM11MPCORE,
|
||||
UARCH_CORTEX_A5,
|
||||
UARCH_CORTEX_A7,
|
||||
UARCH_CORTEX_A8,
|
||||
UARCH_CORTEX_A9,
|
||||
UARCH_CORTEX_A12,
|
||||
UARCH_CORTEX_A15,
|
||||
UARCH_CORTEX_A17,
|
||||
UARCH_CORTEX_A32,
|
||||
UARCH_CORTEX_A35,
|
||||
UARCH_CORTEX_A53,
|
||||
UARCH_CORTEX_A55r0, // ARM Cortex-A55 revision 0 (restricted dual-issue capabilities compared to revision 1+).
|
||||
UARCH_CORTEX_A55,
|
||||
UARCH_CORTEX_A57,
|
||||
UARCH_CORTEX_A65,
|
||||
UARCH_CORTEX_A72,
|
||||
UARCH_CORTEX_A73,
|
||||
UARCH_CORTEX_A75,
|
||||
UARCH_CORTEX_A76,
|
||||
UARCH_CORTEX_A77,
|
||||
UARCH_CORTEX_A78,
|
||||
UARCH_CORTEX_A78AE,
|
||||
UARCH_CORTEX_A78C,
|
||||
UARCH_CORTEX_A510,
|
||||
UARCH_CORTEX_A520,
|
||||
UARCH_CORTEX_A710,
|
||||
UARCH_CORTEX_A715,
|
||||
UARCH_CORTEX_A720,
|
||||
UARCH_CORTEX_A725,
|
||||
UARCH_CORTEX_X1,
|
||||
UARCH_CORTEX_X1C,
|
||||
UARCH_CORTEX_X2,
|
||||
UARCH_CORTEX_X3,
|
||||
UARCH_CORTEX_X4,
|
||||
UARCH_CORTEX_X925,
|
||||
UARCH_NEOVERSE_N1,
|
||||
UARCH_NEOVERSE_N2,
|
||||
UARCH_NEOVERSE_E1,
|
||||
UARCH_NEOVERSE_V1,
|
||||
UARCH_NEOVERSE_V2,
|
||||
UARCH_NEOVERSE_V3,
|
||||
UARCH_SCORPION,
|
||||
UARCH_KRAIT,
|
||||
UARCH_KYRO,
|
||||
UARCH_FALKOR,
|
||||
UARCH_SAPHIRA,
|
||||
UARCH_DENVER,
|
||||
UARCH_DENVER2,
|
||||
UARCH_CARMEL,
|
||||
// SAMSUNG
|
||||
UARCH_EXYNOS_M1, // Samsung Exynos M1 (Exynos 8890 big cores)
|
||||
UARCH_EXYNOS_M2, // Samsung Exynos M2 (Exynos 8895 big cores)
|
||||
UARCH_EXYNOS_M3, // Samsung Exynos M3 (Exynos 9810 big cores)
|
||||
UARCH_EXYNOS_M4, // Samsung Exynos M4 (Exynos 9820 big cores)
|
||||
UARCH_EXYNOS_M5, // Samsung Exynos M5 (Exynos 9830 big cores)
|
||||
// APPLE
|
||||
UARCH_SWIFT, // Apple A6 and A6X processors.
|
||||
UARCH_CYCLONE, // Apple A7 processor.
|
||||
UARCH_TYPHOON, // Apple A8 and A8X processor
|
||||
UARCH_TWISTER, // Apple A9 and A9X processor.
|
||||
UARCH_HURRICANE, // Apple A10 and A10X processor.
|
||||
UARCH_MONSOON, // Apple A11 processor (big cores).
|
||||
UARCH_MISTRAL, // Apple A11 processor (little cores).
|
||||
UARCH_VORTEX, // Apple A12 processor (big cores).
|
||||
UARCH_TEMPEST, // Apple A12 processor (big cores).
|
||||
UARCH_LIGHTNING, // Apple A13 processor (big cores).
|
||||
UARCH_THUNDER, // Apple A13 processor (little cores).
|
||||
UARCH_ICESTORM, // Apple M1 processor (little cores).
|
||||
UARCH_FIRESTORM, // Apple M1 processor (big cores).
|
||||
UARCH_BLIZZARD, // Apple M2 processor (little cores).
|
||||
UARCH_AVALANCHE, // Apple M2 processor (big cores).
|
||||
UARCH_SAWTOOTH, // Apple M3 processor (little cores).
|
||||
UARCH_EVEREST, // Apple M3 processor (big cores).
|
||||
// CAVIUM
|
||||
UARCH_THUNDERX, // Cavium ThunderX
|
||||
UARCH_THUNDERX2, // Cavium ThunderX2 (originally Broadcom Vulkan).
|
||||
// MARVELL
|
||||
UARCH_PJ4,
|
||||
UARCH_BRAHMA_B15,
|
||||
UARCH_BRAHMA_B53,
|
||||
UARCH_XGENE, // Applied Micro X-Gene.
|
||||
// HUAWEI
|
||||
UARCH_TAISHAN_V110, // HiSilicon TaiShan v110
|
||||
UARCH_TAISHAN_V120, // HiSilicon TaiShan v120
|
||||
UARCH_TAISHAN_V200, // HiSilicon TaiShan v200
|
||||
// PHYTIUM
|
||||
UARCH_XIAOMI, // Not to be confused with Xiaomi Inc
|
||||
};
|
||||
|
||||
typedef uint32_t MICROARCH;
|
||||
|
||||
struct uarch* get_uarch_from_midr(uint32_t midr, struct cpuInfo* cpu);
|
||||
int get_number_of_vpus(struct cpuInfo* cpu);
|
||||
int get_vpus_width(struct cpuInfo* cpu);
|
||||
bool has_fma_support(struct cpuInfo* cpu);
|
||||
char* get_str_uarch(struct cpuInfo* cpu);
|
||||
void free_uarch_struct(struct uarch* arch);
|
||||
MICROARCH get_uarch(struct uarch* arch);
|
||||
|
||||
#endif
|
||||
|
||||
@@ -1,8 +1,9 @@
|
||||
#include "../common/global.h"
|
||||
#include "udev.h"
|
||||
#include "midr.h"
|
||||
|
||||
#define _PATH_DEVICETREE_MODEL "/sys/firmware/devicetree/base/model"
|
||||
#define _PATH_CPUS_PRESENT _PATH_SYS_SYSTEM _PATH_SYS_CPU "/present"
|
||||
#define _PATH_CPUINFO "/proc/cpuinfo"
|
||||
//#define _PATH_CPUINFO "cpuinfo_debug"
|
||||
|
||||
#define CPUINFO_CPU_IMPLEMENTER_STR "CPU implementer\t: "
|
||||
#define CPUINFO_CPU_ARCHITECTURE_STR "CPU architecture: "
|
||||
@@ -10,10 +11,42 @@
|
||||
#define CPUINFO_CPU_PART_STR "CPU part\t: "
|
||||
#define CPUINFO_CPU_REVISION_STR "CPU revision\t: "
|
||||
#define CPUINFO_HARDWARE_STR "Hardware\t: "
|
||||
#define CPUINFO_REVISION_STR "Revision\t: "
|
||||
|
||||
#define CPUINFO_CPU_STRING "processor"
|
||||
|
||||
// https://www.kernel.org/doc/html/latest/core-api/cpu_hotplug.html
|
||||
int get_ncores_from_cpuinfo() {
|
||||
// Examples:
|
||||
// 0-271
|
||||
// 0-5
|
||||
// 0-7
|
||||
int filelen;
|
||||
char* buf;
|
||||
if((buf = read_file(_PATH_CPUS_PRESENT, &filelen)) == NULL) {
|
||||
perror("open");
|
||||
return UNKNOWN;
|
||||
}
|
||||
|
||||
int ncores = 0;
|
||||
char* tmp1 = strstr(buf, "-") + 1;
|
||||
char* tmp2 = strstr(buf, "\n");
|
||||
char ncores_str[filelen];
|
||||
memset(ncores_str, 0, sizeof(char) * filelen);
|
||||
memcpy(ncores_str, tmp1, tmp2-tmp1);
|
||||
|
||||
char* end;
|
||||
errno = 0;
|
||||
ncores = strtol(ncores_str, &end, 10) + 1;
|
||||
if(errno != 0) {
|
||||
perror("strtol");
|
||||
return UNKNOWN;
|
||||
}
|
||||
|
||||
free(buf);
|
||||
|
||||
return ncores;
|
||||
}
|
||||
|
||||
long parse_cpuinfo_field(char* buf, char* field_str, int field_base) {
|
||||
char* tmp = strstr(buf, field_str);
|
||||
if(tmp == NULL) return -1;
|
||||
@@ -23,7 +56,7 @@ long parse_cpuinfo_field(char* buf, char* field_str, int field_base) {
|
||||
errno = 0;
|
||||
long ret = strtol(tmp, &end, field_base);
|
||||
if(errno != 0) {
|
||||
printWarn("strtol: %s:\n", strerror(errno));
|
||||
perror("strtol");
|
||||
return -1;
|
||||
}
|
||||
|
||||
@@ -36,7 +69,7 @@ uint32_t get_midr_from_cpuinfo(uint32_t core, bool* success) {
|
||||
char* buf;
|
||||
*success = true;
|
||||
if((buf = read_file(_PATH_CPUINFO, &filelen)) == NULL) {
|
||||
printWarn("read_file: %s: %s\n", _PATH_CPUINFO, strerror(errno));
|
||||
perror("open");
|
||||
*success = false;
|
||||
return 0;
|
||||
}
|
||||
@@ -63,35 +96,35 @@ uint32_t get_midr_from_cpuinfo(uint32_t core, bool* success) {
|
||||
long ret;
|
||||
|
||||
if ((ret = parse_cpuinfo_field(tmp, CPUINFO_CPU_IMPLEMENTER_STR, 16)) < 0) {
|
||||
printBug("get_midr_from_cpuinfo: Failed parsing cpu_implementer\n");
|
||||
printf("Failed parsing cpu_implementer\n");
|
||||
*success = false;
|
||||
return 0;
|
||||
}
|
||||
cpu_implementer = (uint32_t) ret;
|
||||
|
||||
if ((ret = parse_cpuinfo_field(tmp, CPUINFO_CPU_ARCHITECTURE_STR, 10)) < 0) {
|
||||
printBug("get_midr_from_cpuinfo: Failed parsing cpu_architecture\n");
|
||||
printf("Failed parsing cpu_architecture\n");
|
||||
*success = false;
|
||||
return 0;
|
||||
}
|
||||
cpu_architecture = (uint32_t) 0xF; // Why?
|
||||
|
||||
if ((ret = parse_cpuinfo_field(tmp, CPUINFO_CPU_VARIANT_STR, 16)) < 0) {
|
||||
printBug("get_midr_from_cpuinfo: Failed parsing cpu_variant\n");
|
||||
printf("Failed parsing cpu_variant\n");
|
||||
*success = false;
|
||||
return 0;
|
||||
}
|
||||
cpu_variant = (uint32_t) ret;
|
||||
|
||||
if ((ret = parse_cpuinfo_field(tmp, CPUINFO_CPU_PART_STR, 16)) < 0) {
|
||||
printBug("get_midr_from_cpuinfo: Failed parsing cpu_part\n");
|
||||
printf("Failed parsing cpu_part\n");
|
||||
*success = false;
|
||||
return 0;
|
||||
}
|
||||
cpu_part = (uint32_t) ret;
|
||||
|
||||
if ((ret = parse_cpuinfo_field(tmp, CPUINFO_CPU_REVISION_STR, 10)) < 0) {
|
||||
printBug("get_midr_from_cpuinfo: Failed parsing cpu_revision\n");
|
||||
printf("Failed parsing cpu_revision\n");
|
||||
*success = false;
|
||||
return 0;
|
||||
}
|
||||
@@ -106,24 +139,24 @@ uint32_t get_midr_from_cpuinfo(uint32_t core, bool* success) {
|
||||
return midr;
|
||||
}
|
||||
|
||||
char* get_hardware_from_cpuinfo(void) {
|
||||
return get_field_from_cpuinfo(CPUINFO_HARDWARE_STR);
|
||||
}
|
||||
|
||||
char* get_revision_from_cpuinfo(void) {
|
||||
return get_field_from_cpuinfo(CPUINFO_REVISION_STR);
|
||||
}
|
||||
|
||||
bool is_raspberry_pi(void) {
|
||||
char* get_hardware_from_cpuinfo() {
|
||||
int filelen;
|
||||
char* buf;
|
||||
if((buf = read_file(_PATH_DEVICETREE_MODEL, &filelen)) == NULL) {
|
||||
return false;
|
||||
if((buf = read_file(_PATH_CPUINFO, &filelen)) == NULL) {
|
||||
perror("open");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
char* tmp;
|
||||
if((tmp = strstr(buf, "Raspberry Pi")) == NULL) {
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
char* tmp1 = strstr(buf, CPUINFO_HARDWARE_STR);
|
||||
if(tmp1 == NULL) return NULL;
|
||||
tmp1 = tmp1 + strlen(CPUINFO_HARDWARE_STR);
|
||||
char* tmp2 = strstr(tmp1, "\n");
|
||||
|
||||
int strlen = (1 + (tmp2-tmp1));
|
||||
char* hardware = malloc(sizeof(char) * strlen);
|
||||
memset(hardware, 0, sizeof(char) * strlen);
|
||||
strncpy(hardware, tmp1, tmp2-tmp1);
|
||||
|
||||
return hardware;
|
||||
}
|
||||
|
||||
|
||||
@@ -3,16 +3,10 @@
|
||||
|
||||
#include "../common/udev.h"
|
||||
|
||||
#define _PATH_SUNXI_NVMEM "/sys/bus/nvmem/devices/sunxi-sid0/nvmem"
|
||||
#define _PATH_RK_EFUSE0 "/sys/bus/nvmem/devices/rockchip-efuse0/nvmem"
|
||||
#define _PATH_RK_OTP0 "/sys/bus/nvmem/devices/rockchip-otp0/nvmem"
|
||||
|
||||
#define UNKNOWN -1
|
||||
int get_ncores_from_cpuinfo(void);
|
||||
int get_ncores_from_cpuinfo();
|
||||
uint32_t get_midr_from_cpuinfo(uint32_t core, bool* success);
|
||||
char* get_hardware_from_cpuinfo(void);
|
||||
char* get_revision_from_cpuinfo(void);
|
||||
bool is_raspberry_pi(void);
|
||||
char* get_hardware_from_cpuinfo();
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
@@ -5,15 +5,9 @@
|
||||
#include "args.h"
|
||||
#include "global.h"
|
||||
|
||||
#define NUM_COLORS 5
|
||||
|
||||
#define COLOR_STR_INTEL "intel"
|
||||
#define COLOR_STR_INTEL_NEW "intel-new"
|
||||
#define COLOR_STR_AMD "amd"
|
||||
#define COLOR_STR_IBM "ibm"
|
||||
#define COLOR_STR_ARM "arm"
|
||||
#define COLOR_STR_ROCKCHIP "rockchip"
|
||||
#define COLOR_STR_SIFIVE "sifive"
|
||||
|
||||
static const char *SYTLES_STR_LIST[] = {
|
||||
[STYLE_EMPTY] = NULL,
|
||||
@@ -23,124 +17,50 @@ static const char *SYTLES_STR_LIST[] = {
|
||||
[STYLE_INVALID] = NULL
|
||||
};
|
||||
|
||||
enum {
|
||||
ARG_CHAR_STYLE,
|
||||
ARG_CHAR_COLOR,
|
||||
ARG_CHAR_HELP,
|
||||
ARG_CHAR_DEBUG,
|
||||
ARG_CHAR_VERBOSE,
|
||||
ARG_CHAR_VERSION
|
||||
};
|
||||
|
||||
struct args_struct {
|
||||
bool debug_flag;
|
||||
bool help_flag;
|
||||
bool raw_flag;
|
||||
bool accurate_pp;
|
||||
bool measure_max_frequency_flag;
|
||||
bool full_cpu_name_flag;
|
||||
bool logo_long;
|
||||
bool logo_short;
|
||||
bool logo_intel_new;
|
||||
bool logo_intel_old;
|
||||
bool verbose_flag;
|
||||
bool version_flag;
|
||||
STYLE style;
|
||||
struct color** colors;
|
||||
};
|
||||
|
||||
const char args_chr[] = {
|
||||
/* [ARG_STYLE] = */ 's',
|
||||
/* [ARG_COLOR] = */ 'c',
|
||||
/* [ARG_HELP] = */ 'h',
|
||||
/* [ARG_RAW] = */ 'r',
|
||||
/* [ARG_FULLCPUNAME] = */ 'F',
|
||||
/* [ARG_LOGO_LONG] = */ 1,
|
||||
/* [ARG_LOGO_SHORT] = */ 2,
|
||||
/* [ARG_LOGO_INTEL_NEW] = */ 3,
|
||||
/* [ARG_LOGO_INTEL_OLD] = */ 4,
|
||||
/* [ARG_ACCURATE_PP] = */ 5,
|
||||
/* [ARG_MEASURE_MAX_FREQ] = */ 6,
|
||||
/* [ARG_DEBUG] = */ 'd',
|
||||
/* [ARG_VERBOSE] = */ 'v',
|
||||
/* [ARG_VERSION] = */ 'V',
|
||||
};
|
||||
|
||||
const char *args_str[] = {
|
||||
/* [ARG_STYLE] = */ "style",
|
||||
/* [ARG_COLOR] = */ "color",
|
||||
/* [ARG_HELP] = */ "help",
|
||||
/* [ARG_RAW] = */ "raw",
|
||||
/* [ARG_FULLCPUNAME] = */ "full-cpu-name",
|
||||
/* [ARG_LOGO_LONG] = */ "logo-long",
|
||||
/* [ARG_LOGO_SHORT] = */ "logo-short",
|
||||
/* [ARG_LOGO_INTEL_NEW] = */ "logo-intel-new",
|
||||
/* [ARG_LOGO_INTEL_OLD] = */ "logo-intel-old",
|
||||
/* [ARG_ACCURATE_PP] = */ "accurate-pp",
|
||||
/* [ARG_MEASURE_MAX_FREQ] = */ "measure-max-freq",
|
||||
/* [ARG_DEBUG] = */ "debug",
|
||||
/* [ARG_VERBOSE] = */ "verbose",
|
||||
/* [ARG_VERSION] = */ "version",
|
||||
struct colors* colors;
|
||||
};
|
||||
|
||||
static struct args_struct args;
|
||||
|
||||
STYLE get_style(void) {
|
||||
STYLE get_style() {
|
||||
return args.style;
|
||||
}
|
||||
|
||||
struct color** get_colors(void) {
|
||||
struct colors* get_colors() {
|
||||
return args.colors;
|
||||
}
|
||||
|
||||
bool show_help(void) {
|
||||
bool show_help() {
|
||||
return args.help_flag;
|
||||
}
|
||||
|
||||
bool show_version(void) {
|
||||
bool show_version() {
|
||||
return args.version_flag;
|
||||
}
|
||||
|
||||
bool show_debug(void) {
|
||||
bool show_debug() {
|
||||
return args.debug_flag;
|
||||
}
|
||||
|
||||
bool show_raw(void) {
|
||||
return args.raw_flag;
|
||||
}
|
||||
|
||||
bool accurate_pp(void) {
|
||||
return args.accurate_pp;
|
||||
}
|
||||
|
||||
bool measure_max_frequency_flag(void) {
|
||||
return args.measure_max_frequency_flag;
|
||||
}
|
||||
|
||||
bool show_full_cpu_name(void) {
|
||||
return args.full_cpu_name_flag;
|
||||
}
|
||||
|
||||
bool show_logo_long(void) {
|
||||
return args.logo_long;
|
||||
}
|
||||
|
||||
bool show_logo_short(void) {
|
||||
return args.logo_short;
|
||||
}
|
||||
|
||||
bool show_logo_intel_new(void) {
|
||||
return args.logo_intel_new;
|
||||
}
|
||||
|
||||
bool show_logo_intel_old(void) {
|
||||
return args.logo_intel_old;
|
||||
}
|
||||
|
||||
bool verbose_enabled(void) {
|
||||
bool verbose_enabled() {
|
||||
return args.verbose_flag;
|
||||
}
|
||||
|
||||
int max_arg_str_length(void) {
|
||||
int max_len = -1;
|
||||
int len = sizeof(args_str) / sizeof(args_str[0]);
|
||||
for(int i=0; i < len; i++) {
|
||||
max_len = max(max_len, (int) strlen(args_str[i]));
|
||||
}
|
||||
return max_len;
|
||||
}
|
||||
|
||||
STYLE parse_style(char* style) {
|
||||
uint8_t i = 0;
|
||||
uint8_t styles_count = sizeof(SYTLES_STR_LIST) / sizeof(SYTLES_STR_LIST[0]);
|
||||
@@ -154,67 +74,83 @@ STYLE parse_style(char* style) {
|
||||
return i;
|
||||
}
|
||||
|
||||
void free_colors_struct(struct color** cs) {
|
||||
for(int i=0; i < NUM_COLORS; i++) {
|
||||
free(cs[i]);
|
||||
}
|
||||
void free_colors_struct(struct colors* cs) {
|
||||
free(cs->c1);
|
||||
free(cs->c2);
|
||||
free(cs->c3);
|
||||
free(cs->c4);
|
||||
free(cs);
|
||||
}
|
||||
|
||||
bool parse_color(char* optarg_str, struct color*** cs) {
|
||||
for(int i=0; i < NUM_COLORS; i++) {
|
||||
(*cs)[i] = emalloc(sizeof(struct color));
|
||||
}
|
||||
|
||||
struct color** c = *cs;
|
||||
bool parse_color(char* optarg_str, struct colors** cs) {
|
||||
*cs = malloc(sizeof(struct colors));
|
||||
(*cs)->c1 = malloc(sizeof(struct color));
|
||||
(*cs)->c2 = malloc(sizeof(struct color));
|
||||
(*cs)->c3 = malloc(sizeof(struct color));
|
||||
(*cs)->c4 = malloc(sizeof(struct color));
|
||||
struct color** c1 = &((*cs)->c1);
|
||||
struct color** c2 = &((*cs)->c2);
|
||||
struct color** c3 = &((*cs)->c3);
|
||||
struct color** c4 = &((*cs)->c4);
|
||||
int32_t ret;
|
||||
char* str_to_parse = NULL;
|
||||
char* color_to_copy = NULL;
|
||||
bool free_ptr = true;
|
||||
bool free_ptr;
|
||||
|
||||
if(strcmp(optarg_str, COLOR_STR_INTEL) == 0) color_to_copy = COLOR_DEFAULT_INTEL;
|
||||
else if(strcmp(optarg_str, COLOR_STR_INTEL_NEW) == 0) color_to_copy = COLOR_DEFAULT_INTEL_NEW;
|
||||
else if(strcmp(optarg_str, COLOR_STR_AMD) == 0) color_to_copy = COLOR_DEFAULT_AMD;
|
||||
else if(strcmp(optarg_str, COLOR_STR_IBM) == 0) color_to_copy = COLOR_DEFAULT_IBM;
|
||||
else if(strcmp(optarg_str, COLOR_STR_ARM) == 0) color_to_copy = COLOR_DEFAULT_ARM;
|
||||
else if(strcmp(optarg_str, COLOR_STR_ROCKCHIP) == 0) color_to_copy = COLOR_DEFAULT_ROCKCHIP;
|
||||
else if(strcmp(optarg_str, COLOR_STR_SIFIVE) == 0) color_to_copy = COLOR_DEFAULT_SIFIVE;
|
||||
if(strcmp(optarg_str, COLOR_STR_INTEL) == 0) {
|
||||
str_to_parse = malloc(sizeof(char) * 46);
|
||||
strcpy(str_to_parse, COLOR_DEFAULT_INTEL);
|
||||
free_ptr = true;
|
||||
}
|
||||
else if(strcmp(optarg_str, COLOR_STR_AMD) == 0) {
|
||||
str_to_parse = malloc(sizeof(char) * 44);
|
||||
strcpy(str_to_parse, COLOR_DEFAULT_AMD);
|
||||
free_ptr = true;
|
||||
}
|
||||
else if(strcmp(optarg_str, COLOR_STR_ARM) == 0) {
|
||||
str_to_parse = malloc(sizeof(char) * 46);
|
||||
strcpy(str_to_parse, COLOR_DEFAULT_ARM);
|
||||
free_ptr = true;
|
||||
}
|
||||
else {
|
||||
str_to_parse = optarg_str;
|
||||
free_ptr = false;
|
||||
}
|
||||
|
||||
if(str_to_parse == NULL) {
|
||||
str_to_parse = emalloc(sizeof(char) * (strlen(color_to_copy) + 1));
|
||||
strcpy(str_to_parse, color_to_copy);
|
||||
}
|
||||
ret = sscanf(str_to_parse, "%d,%d,%d:%d,%d,%d:%d,%d,%d:%d,%d,%d",
|
||||
&(*c1)->R, &(*c1)->G, &(*c1)->B,
|
||||
&(*c2)->R, &(*c2)->G, &(*c2)->B,
|
||||
&(*c3)->R, &(*c3)->G, &(*c3)->B,
|
||||
&(*c4)->R, &(*c4)->G, &(*c4)->B);
|
||||
|
||||
ret = sscanf(str_to_parse, "%d,%d,%d:%d,%d,%d:%d,%d,%d:%d,%d,%d:%d,%d,%d",
|
||||
&c[0]->R, &c[0]->G, &c[0]->B,
|
||||
&c[1]->R, &c[1]->G, &c[1]->B,
|
||||
&c[2]->R, &c[2]->G, &c[2]->B,
|
||||
&c[3]->R, &c[3]->G, &c[3]->B,
|
||||
&c[4]->R, &c[4]->G, &c[4]->B);
|
||||
|
||||
int expected_colors = 3 * NUM_COLORS;
|
||||
if(ret != expected_colors) {
|
||||
printErr("Expected to read %d values for color but read %d", expected_colors, ret);
|
||||
if(ret != 12) {
|
||||
printErr("Expected to read 12 values for color but read %d", ret);
|
||||
return false;
|
||||
}
|
||||
|
||||
for(int i=0; i < NUM_COLORS; i++) {
|
||||
if(c[i]->R < 0 || c[i]->R > 255) {
|
||||
printErr("Red in color %d is invalid: %d; must be in range (0, 255)", i+1, c[i]->R);
|
||||
//TODO: Refactor c1->R c2->R ... to c[i]->R
|
||||
if((*c1)->R < 0 || (*c1)->R > 255) {
|
||||
printErr("Red in color 1 is invalid. Must be in range (0, 255)");
|
||||
return false;
|
||||
}
|
||||
if(c[i]->G < 0 || c[i]->G > 255) {
|
||||
printErr("Green in color %d is invalid: %d; must be in range (0, 255)", i+1, c[i]->G);
|
||||
if((*c1)->G < 0 || (*c1)->G > 255) {
|
||||
printErr("Green in color 1 is invalid. Must be in range (0, 255)");
|
||||
return false;
|
||||
}
|
||||
if(c[i]->B < 0 || c[i]->B > 255) {
|
||||
printErr("Blue in color %d is invalid: %d; must be in range (0, 255)", i+1, c[i]->B);
|
||||
if((*c1)->B < 0 || (*c1)->B > 255) {
|
||||
printErr("Blue in color 1 is invalid. Must be in range (0, 255)");
|
||||
return false;
|
||||
}
|
||||
if((*c2)->R < 0 || (*c2)->R > 255) {
|
||||
printErr("Red in color 2 is invalid. Must be in range (0, 255)");
|
||||
return false;
|
||||
}
|
||||
if((*c2)->G < 0 || (*c2)->G > 255) {
|
||||
printErr("Green in color 2 is invalid. Must be in range (0, 255)");
|
||||
return false;
|
||||
}
|
||||
if((*c2)->B < 0 || (*c2)->B > 255) {
|
||||
printErr("Blue in color 2 is invalid. Must be in range (0, 255)");
|
||||
return false;
|
||||
}
|
||||
|
||||
if(free_ptr) free (str_to_parse);
|
||||
@@ -222,98 +158,43 @@ bool parse_color(char* optarg_str, struct color*** cs) {
|
||||
return true;
|
||||
}
|
||||
|
||||
char* build_short_options(void) {
|
||||
const char *c = args_chr;
|
||||
int len = sizeof(args_chr) / sizeof(args_chr[0]);
|
||||
char* str = (char *) ecalloc(len*2 + 1, sizeof(char));
|
||||
|
||||
#ifdef ARCH_X86
|
||||
sprintf(str, "%c:%c:%c%c%c%c%c%c%c%c%c%c%c%c",
|
||||
c[ARG_STYLE], c[ARG_COLOR], c[ARG_HELP],
|
||||
c[ARG_RAW], c[ARG_FULLCPUNAME],
|
||||
c[ARG_LOGO_SHORT], c[ARG_LOGO_LONG],
|
||||
c[ARG_LOGO_INTEL_NEW], c[ARG_LOGO_INTEL_OLD],
|
||||
c[ARG_ACCURATE_PP], c[ARG_MEASURE_MAX_FREQ],
|
||||
c[ARG_DEBUG], c[ARG_VERBOSE],
|
||||
c[ARG_VERSION]);
|
||||
#elif ARCH_ARM
|
||||
sprintf(str, "%c:%c:%c%c%c%c%c%c%c",
|
||||
c[ARG_STYLE], c[ARG_COLOR], c[ARG_HELP],
|
||||
c[ARG_LOGO_SHORT], c[ARG_LOGO_LONG],
|
||||
c[ARG_MEASURE_MAX_FREQ],
|
||||
c[ARG_DEBUG], c[ARG_VERBOSE],
|
||||
c[ARG_VERSION]);
|
||||
#else
|
||||
sprintf(str, "%c:%c:%c%c%c%c%c%c",
|
||||
c[ARG_STYLE], c[ARG_COLOR], c[ARG_HELP],
|
||||
c[ARG_LOGO_SHORT], c[ARG_LOGO_LONG],
|
||||
c[ARG_DEBUG], c[ARG_VERBOSE],
|
||||
c[ARG_VERSION]);
|
||||
#endif
|
||||
|
||||
return str;
|
||||
}
|
||||
|
||||
bool parse_args(int argc, char* argv[]) {
|
||||
int opt;
|
||||
int c;
|
||||
int option_index = 0;
|
||||
opterr = 0;
|
||||
|
||||
bool color_flag = false;
|
||||
args.debug_flag = false;
|
||||
args.accurate_pp = false;
|
||||
args.full_cpu_name_flag = false;
|
||||
args.raw_flag = false;
|
||||
args.verbose_flag = false;
|
||||
args.logo_long = false;
|
||||
args.logo_short = false;
|
||||
args.logo_intel_new = false;
|
||||
args.logo_intel_old = false;
|
||||
args.help_flag = false;
|
||||
args.style = STYLE_EMPTY;
|
||||
args.colors = NULL;
|
||||
|
||||
// Temporary enable verbose level to allow printing warnings inside parse_args
|
||||
set_log_level(true);
|
||||
|
||||
const struct option long_options[] = {
|
||||
{args_str[ARG_STYLE], required_argument, 0, args_chr[ARG_STYLE] },
|
||||
{args_str[ARG_COLOR], required_argument, 0, args_chr[ARG_COLOR] },
|
||||
{args_str[ARG_HELP], no_argument, 0, args_chr[ARG_HELP] },
|
||||
#ifdef ARCH_X86
|
||||
{args_str[ARG_LOGO_INTEL_NEW], no_argument, 0, args_chr[ARG_LOGO_INTEL_NEW] },
|
||||
{args_str[ARG_LOGO_INTEL_OLD], no_argument, 0, args_chr[ARG_LOGO_INTEL_OLD] },
|
||||
{args_str[ARG_ACCURATE_PP], no_argument, 0, args_chr[ARG_ACCURATE_PP] },
|
||||
{args_str[ARG_MEASURE_MAX_FREQ], no_argument, 0, args_chr[ARG_MEASURE_MAX_FREQ] },
|
||||
{args_str[ARG_FULLCPUNAME], no_argument, 0, args_chr[ARG_FULLCPUNAME] },
|
||||
{args_str[ARG_RAW], no_argument, 0, args_chr[ARG_RAW] },
|
||||
#elif ARCH_ARM
|
||||
{args_str[ARG_MEASURE_MAX_FREQ], no_argument, 0, args_chr[ARG_MEASURE_MAX_FREQ] },
|
||||
#endif
|
||||
{args_str[ARG_LOGO_SHORT], no_argument, 0, args_chr[ARG_LOGO_SHORT] },
|
||||
{args_str[ARG_LOGO_LONG], no_argument, 0, args_chr[ARG_LOGO_LONG] },
|
||||
{args_str[ARG_DEBUG], no_argument, 0, args_chr[ARG_DEBUG] },
|
||||
{args_str[ARG_VERBOSE], no_argument, 0, args_chr[ARG_VERBOSE] },
|
||||
{args_str[ARG_VERSION], no_argument, 0, args_chr[ARG_VERSION] },
|
||||
static struct option long_options[] = {
|
||||
{"style", required_argument, 0, ARG_CHAR_STYLE },
|
||||
{"color", required_argument, 0, ARG_CHAR_COLOR },
|
||||
{"help", no_argument, 0, ARG_CHAR_HELP },
|
||||
{"debug", no_argument, 0, ARG_CHAR_DEBUG },
|
||||
{"verbose", no_argument, 0, ARG_CHAR_VERBOSE },
|
||||
{"version", no_argument, 0, ARG_CHAR_VERSION },
|
||||
{0, 0, 0, 0}
|
||||
};
|
||||
|
||||
char* short_options = build_short_options();
|
||||
opt = getopt_long(argc, argv, short_options, long_options, &option_index);
|
||||
c = getopt_long(argc, argv, "", long_options, &option_index);
|
||||
|
||||
while (!args.help_flag && !args.debug_flag && !args.version_flag && opt != -1) {
|
||||
if(opt == args_chr[ARG_COLOR]) {
|
||||
while (c != -1) {
|
||||
if(c == ARG_CHAR_COLOR) {
|
||||
if(color_flag) {
|
||||
printErr("Color option specified more than once");
|
||||
return false;
|
||||
}
|
||||
color_flag = true;
|
||||
args.colors = emalloc(sizeof(struct color *) * NUM_COLORS);
|
||||
if(!parse_color(optarg, &args.colors)) {
|
||||
printErr("Color parsing failed");
|
||||
return false;
|
||||
}
|
||||
}
|
||||
else if(opt == args_chr[ARG_STYLE]) {
|
||||
else if(c == ARG_CHAR_STYLE) {
|
||||
if(args.style != STYLE_EMPTY) {
|
||||
printErr("Style option specified more than once");
|
||||
return false;
|
||||
@@ -324,49 +205,44 @@ bool parse_args(int argc, char* argv[]) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
else if(opt == args_chr[ARG_HELP]) {
|
||||
else if(c == ARG_CHAR_HELP) {
|
||||
if(args.help_flag) {
|
||||
printErr("Help option specified more than once");
|
||||
return false;
|
||||
}
|
||||
args.help_flag = true;
|
||||
}
|
||||
else if(opt == args_chr[ARG_ACCURATE_PP]) {
|
||||
args.accurate_pp = true;
|
||||
else if(c == ARG_CHAR_VERBOSE) {
|
||||
if(args.verbose_flag) {
|
||||
printErr("Verbose option specified more than once");
|
||||
return false;
|
||||
}
|
||||
else if(opt == args_chr[ARG_MEASURE_MAX_FREQ]) {
|
||||
args.measure_max_frequency_flag = true;
|
||||
}
|
||||
else if(opt == args_chr[ARG_FULLCPUNAME]) {
|
||||
args.full_cpu_name_flag = true;
|
||||
}
|
||||
else if(opt == args_chr[ARG_LOGO_SHORT]) {
|
||||
args.logo_short = true;
|
||||
}
|
||||
else if(opt == args_chr[ARG_LOGO_LONG]) {
|
||||
args.logo_long = true;
|
||||
}
|
||||
else if(opt == args_chr[ARG_LOGO_INTEL_NEW]) {
|
||||
args.logo_intel_new = true;
|
||||
}
|
||||
else if(opt == args_chr[ARG_LOGO_INTEL_OLD]) {
|
||||
args.logo_intel_old = true;
|
||||
}
|
||||
else if(opt == args_chr[ARG_RAW]) {
|
||||
args.raw_flag = true;
|
||||
}
|
||||
else if(opt == args_chr[ARG_VERBOSE]) {
|
||||
args.verbose_flag = true;
|
||||
}
|
||||
else if(opt == args_chr[ARG_DEBUG]) {
|
||||
else if(c == ARG_CHAR_DEBUG) {
|
||||
if(args.debug_flag) {
|
||||
printErr("Debug option specified more than once");
|
||||
return false;
|
||||
}
|
||||
args.debug_flag = true;
|
||||
}
|
||||
else if(opt == args_chr[ARG_VERSION]) {
|
||||
else if (c == ARG_CHAR_VERSION) {
|
||||
if(args.version_flag) {
|
||||
printErr("Version option specified more than once");
|
||||
return false;
|
||||
}
|
||||
args.version_flag = true;
|
||||
}
|
||||
else {
|
||||
else if(c == '?') {
|
||||
printWarn("Invalid options");
|
||||
args.help_flag = true;
|
||||
break;
|
||||
}
|
||||
else
|
||||
printBug("Bug at line number %d in file %s", __LINE__, __FILE__);
|
||||
|
||||
option_index = 0;
|
||||
opt = getopt_long(argc, argv, short_options, long_options, &option_index);
|
||||
c = getopt_long(argc, argv,"",long_options, &option_index);
|
||||
}
|
||||
|
||||
if (optind < argc) {
|
||||
@@ -374,27 +250,10 @@ bool parse_args(int argc, char* argv[]) {
|
||||
args.help_flag = true;
|
||||
}
|
||||
|
||||
if(args.logo_intel_new && args.logo_intel_old) {
|
||||
printWarn("%s and %s cannot be specified together", args_str[ARG_LOGO_INTEL_NEW], args_str[ARG_LOGO_INTEL_OLD]);
|
||||
args.logo_intel_new = false;
|
||||
args.logo_intel_old = false;
|
||||
}
|
||||
|
||||
if(args.logo_short && args.logo_long) {
|
||||
printWarn("%s and %s cannot be specified together", args_str[ARG_LOGO_SHORT], args_str[ARG_LOGO_LONG]);
|
||||
args.logo_short = false;
|
||||
args.logo_long = false;
|
||||
}
|
||||
|
||||
#if defined(ARCH_X86) && ! defined(__linux__)
|
||||
if(args.accurate_pp) {
|
||||
printWarn("%s option is valid only in Linux x86_64", args_str[ARG_ACCURATE_PP]);
|
||||
if((args.help_flag + args.version_flag + color_flag) > 1) {
|
||||
printWarn("You should specify just one option");
|
||||
args.help_flag = true;
|
||||
}
|
||||
#endif
|
||||
|
||||
// Leave log level untouched after returning
|
||||
set_log_level(false);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
@@ -10,52 +10,31 @@ struct color {
|
||||
int32_t B;
|
||||
};
|
||||
|
||||
struct colors {
|
||||
struct color* c1;
|
||||
struct color* c2;
|
||||
struct color* c3;
|
||||
struct color* c4;
|
||||
};
|
||||
|
||||
enum {
|
||||
STYLE_EMPTY,
|
||||
STYLE_FANCY,
|
||||
STYLE_WILD,
|
||||
STYLE_RETRO,
|
||||
STYLE_LEGACY,
|
||||
STYLE_INVALID
|
||||
};
|
||||
|
||||
enum {
|
||||
ARG_STYLE,
|
||||
ARG_COLOR,
|
||||
ARG_HELP,
|
||||
ARG_RAW,
|
||||
ARG_FULLCPUNAME,
|
||||
ARG_LOGO_LONG,
|
||||
ARG_LOGO_SHORT,
|
||||
ARG_LOGO_INTEL_NEW,
|
||||
ARG_LOGO_INTEL_OLD,
|
||||
ARG_ACCURATE_PP,
|
||||
ARG_MEASURE_MAX_FREQ,
|
||||
ARG_DEBUG,
|
||||
ARG_VERBOSE,
|
||||
ARG_VERSION
|
||||
};
|
||||
|
||||
extern const char args_chr[];
|
||||
extern const char *args_str[];
|
||||
|
||||
#include "printer.h"
|
||||
|
||||
int max_arg_str_length(void);
|
||||
bool parse_args(int argc, char* argv[]);
|
||||
bool show_help(void);
|
||||
bool accurate_pp(void);
|
||||
bool measure_max_frequency_flag(void);
|
||||
bool show_full_cpu_name(void);
|
||||
bool show_logo_long(void);
|
||||
bool show_logo_short(void);
|
||||
bool show_logo_intel_new(void);
|
||||
bool show_logo_intel_old(void);
|
||||
bool show_raw(void);
|
||||
bool show_debug(void);
|
||||
bool show_version(void);
|
||||
bool verbose_enabled(void);
|
||||
void free_colors_struct(struct color** cs);
|
||||
struct color** get_colors(void);
|
||||
STYLE get_style(void);
|
||||
bool show_help();
|
||||
bool show_debug();
|
||||
bool show_version();
|
||||
bool verbose_enabled();
|
||||
void free_colors_struct(struct colors* cs);
|
||||
struct colors* get_colors();
|
||||
STYLE get_style();
|
||||
|
||||
#endif
|
||||
|
||||
@@ -1,626 +1,208 @@
|
||||
#ifndef __ASCII__
|
||||
#define __ASCII__
|
||||
|
||||
#define COLOR_NONE ""
|
||||
#define C_FG_BLACK "\x1b[30;1m"
|
||||
#define C_FG_RED "\x1b[31;1m"
|
||||
#define C_FG_GREEN "\x1b[32;1m"
|
||||
#define C_FG_YELLOW "\x1b[33;1m"
|
||||
#define C_FG_BLUE "\x1b[34;1m"
|
||||
#define C_FG_MAGENTA "\x1b[35;1m"
|
||||
#define C_FG_CYAN "\x1b[36;1m"
|
||||
#define C_FG_WHITE "\x1b[37;1m"
|
||||
#define C_BG_BLACK "\x1b[40;1m"
|
||||
#define C_BG_RED "\x1b[41;1m"
|
||||
#define C_BG_GREEN "\x1b[42;1m"
|
||||
#define C_BG_YELLOW "\x1b[43;1m"
|
||||
#define C_BG_BLUE "\x1b[44;1m"
|
||||
#define C_BG_MAGENTA "\x1b[45;1m"
|
||||
#define C_BG_CYAN "\x1b[46;1m"
|
||||
#define C_BG_WHITE "\x1b[47;1m"
|
||||
#define C_FG_B_BLACK "\x1b[90;1m"
|
||||
#define C_FG_B_RED "\x1b[91;1m"
|
||||
#define C_FG_B_GREEN "\x1b[92;1m"
|
||||
#define C_FG_B_YELLOW "\x1b[93;1m"
|
||||
#define C_FG_B_BLUE "\x1b[94;1m"
|
||||
#define C_FG_B_MAGENTA "\x1b[95;1m"
|
||||
#define C_FG_B_CYAN "\x1b[96;1m"
|
||||
#define C_FG_B_WHITE "\x1b[97;1m"
|
||||
#define COLOR_RESET "\x1b[m"
|
||||
#define NUMBER_OF_LINES 19
|
||||
#define LINE_SIZE 62
|
||||
|
||||
struct ascii_logo {
|
||||
char* art;
|
||||
uint32_t width;
|
||||
uint32_t height;
|
||||
bool replace_blocks;
|
||||
char color_ascii[4][100];
|
||||
char color_text[2][100];
|
||||
#define AMD_ASCII \
|
||||
" \
|
||||
\
|
||||
\
|
||||
\
|
||||
\
|
||||
\
|
||||
@@@@ @@@ @@@ @@@@@@@@ ############ \
|
||||
@@@@@@ @@@@@ @@@@ @@@ @@@@ ########## \
|
||||
@@@ @@@ @@@@@@@@@@@@@ @@@ @@ # #### \
|
||||
@@@ @@@ @@@ @@@ @@@ @@@ @@@ ### #### \
|
||||
@@@@@@@@@@@@ @@@ @@@ @@@ @@@ #### ## ### \
|
||||
@@@ @@@ @@@ @@@ @@@@@@@@@ ######## ## \
|
||||
\
|
||||
\
|
||||
\
|
||||
\
|
||||
\
|
||||
\
|
||||
"
|
||||
|
||||
#define INTEL_ASCII \
|
||||
" ################ \
|
||||
####### ####### \
|
||||
#### #### \
|
||||
### #### \
|
||||
### ### \
|
||||
### ### \
|
||||
# ### ### ### \
|
||||
## ### ######### ###### ###### ### ### \
|
||||
## ### ### ### ### #### #### ### ### \
|
||||
## ### ### ### ### ### ### ### ### \
|
||||
## ### ### ### ### ########## ### #### \
|
||||
## ### ### ### ### ### ### ##### \
|
||||
## ## ### ### ##### ######### ## ### \
|
||||
### \
|
||||
### \
|
||||
#### #### \
|
||||
##### ########## \
|
||||
########## ################ \
|
||||
############################### "
|
||||
|
||||
#define SNAPDRAGON_ASCII \
|
||||
" \
|
||||
@@######## \
|
||||
@@@@@########### \
|
||||
@@ @@@@@################# \
|
||||
@@@@@@@@@@#################### \
|
||||
@@@@@@@@@@@@##################### \
|
||||
@@@@@@@@@@@@@@@#################### \
|
||||
@@@@@@@@@@@@@@@@@################### \
|
||||
@@@@@@@@@@@@@@@@@@@@################ \
|
||||
@@@@@@@@@@@@@@@@@@@@############# \
|
||||
@@@@@@@@@@@@@@@@@@############ \
|
||||
@ @@@@@@@@@@@@@@@########### \
|
||||
@@@@@ @@@@@@@@@@@@@########## \
|
||||
@@@@@@@@@ @@@@@@@@@@@@######## \
|
||||
@@@@@@@@@ @@@@@@@@@@####### \
|
||||
@@@@@@@@@@@@@@@@####### \
|
||||
@@@@########### \
|
||||
\
|
||||
"
|
||||
|
||||
#define MEDIATEK_ASCII \
|
||||
" \
|
||||
\
|
||||
\
|
||||
\
|
||||
\
|
||||
\
|
||||
## ## ###### ###### # ### @@@@@@ @@@@@@ @@ @@ \
|
||||
### ### # # # # #### @@ @ @@ @@ \
|
||||
######## # ### # # # ## ## @@ @ @@@ @@@@ \
|
||||
## ### ## # # # # ## ## @@ @ @@ @@ \
|
||||
## ## ## ###### ##### # ## ## @@ @@@@@@ @@ @@ \
|
||||
\
|
||||
\
|
||||
\
|
||||
\
|
||||
\
|
||||
\
|
||||
\
|
||||
"
|
||||
|
||||
#define EXYNOS_ASCII \
|
||||
" \
|
||||
\
|
||||
\
|
||||
\
|
||||
\
|
||||
\
|
||||
## ## ## \
|
||||
## ## \
|
||||
## \
|
||||
## ## \
|
||||
## ## ## \
|
||||
\
|
||||
SAMSUNG \
|
||||
Exynos \
|
||||
\
|
||||
\
|
||||
\
|
||||
\
|
||||
"
|
||||
|
||||
#define KIRIN_ASCII \
|
||||
" \
|
||||
\
|
||||
\
|
||||
\
|
||||
\
|
||||
####### \
|
||||
##### #################### \
|
||||
###################################### \
|
||||
####################################### \
|
||||
####################################### \
|
||||
############################## \
|
||||
########################## \
|
||||
######################### \
|
||||
######################## \
|
||||
######################## \
|
||||
######################### \
|
||||
######################### \
|
||||
\
|
||||
"
|
||||
|
||||
#define BROADCOM_ASCII \
|
||||
" \
|
||||
################ \
|
||||
######################### \
|
||||
############################### \
|
||||
################@@@@################ \
|
||||
################@@@@@@################ \
|
||||
#################@@@@@@################ \
|
||||
#################@@@@@@@@################# \
|
||||
#################@@@@@@@@################# \
|
||||
#################@@@@##@@@@################ \
|
||||
################@@@@##@@@@################ \
|
||||
###############@@@@####@@@@############### \
|
||||
@@@@@@@@@@####@@@@####@@@@####@@@@@@@@@@ \
|
||||
######@@@@@@@@@@######@@@@@@@@@@###### \
|
||||
################################## \
|
||||
############################## \
|
||||
######################## \
|
||||
############### \
|
||||
"
|
||||
|
||||
#define ARM_ASCII \
|
||||
" \
|
||||
\
|
||||
\
|
||||
\
|
||||
\
|
||||
\
|
||||
############ ########## #### ###### ######## \
|
||||
############### ######### ####################### \
|
||||
#### #### #### ##### ####### ##### \
|
||||
#### #### #### #### ##### #### \
|
||||
#### #### #### #### #### #### \
|
||||
#### ##### #### #### #### #### \
|
||||
############### #### #### #### #### \
|
||||
######## #### #### #### #### #### \
|
||||
\
|
||||
\
|
||||
\
|
||||
\
|
||||
"
|
||||
|
||||
#define UNKNOWN_ASCII \
|
||||
" \
|
||||
\
|
||||
\
|
||||
\
|
||||
\
|
||||
\
|
||||
\
|
||||
\
|
||||
\
|
||||
\
|
||||
\
|
||||
\
|
||||
\
|
||||
\
|
||||
\
|
||||
\
|
||||
\
|
||||
\
|
||||
"
|
||||
|
||||
static const char* ASCII_ARRAY [] = {
|
||||
AMD_ASCII,
|
||||
INTEL_ASCII,
|
||||
ARM_ASCII,
|
||||
SNAPDRAGON_ASCII,
|
||||
MEDIATEK_ASCII,
|
||||
EXYNOS_ASCII,
|
||||
KIRIN_ASCII,
|
||||
BROADCOM_ASCII,
|
||||
UNKNOWN_ASCII
|
||||
};
|
||||
|
||||
/*
|
||||
* ASCII logos brief documentation
|
||||
* ----------------------------------------------------
|
||||
* C1, C2, ...: ColorN, gets replaced by printer.c with
|
||||
* the color in ascii_logo->color_ascii[N]
|
||||
* CR: Color reset, gets replaced by the reset
|
||||
* color by printer.c
|
||||
*
|
||||
* Logos with replace_blocks=true are replaced by character
|
||||
* blocks (actually, spaces with background color), so
|
||||
* the color in the structure must be C_BG_XXX. When
|
||||
* replace_blocks is true, the characters '#' are replaced
|
||||
* by spaces printed with color_ascii[0], and '@' are
|
||||
* printed with color_ascii[1]. If replace_blocks=true,
|
||||
* color format specified in ASCIIs ($C1, $C2) are ignored.
|
||||
*
|
||||
* In any case, '$' is a illegal character to be used in
|
||||
* the ascii logos because it is used to parse colors
|
||||
*
|
||||
* LONG_LOGOS will be printed only if the fit in the screen,
|
||||
* otherwise SHORT_LOGOS will be used
|
||||
*/
|
||||
|
||||
// SHORT LOGOS //
|
||||
#define ASCII_AMD \
|
||||
"$C2 '############### \
|
||||
$C2 ,############# \
|
||||
$C2 .#### \
|
||||
$C2 #. .#### \
|
||||
$C2 :##. .#### \
|
||||
$C2 :###. .#### \
|
||||
$C2 #########. :## \
|
||||
$C2 #######. ; \
|
||||
$C1 \
|
||||
$C1 ### ### ### ####### \
|
||||
$C1 ## ## ##### ##### ## ## \
|
||||
$C1 ## ## ### #### ### ## ## \
|
||||
$C1 ######### ### ## ### ## ## \
|
||||
$C1## ## ### ### ## ## \
|
||||
$C1## ## ### ### ####### "
|
||||
|
||||
#define ASCII_INTEL \
|
||||
"$C1 .#################. \
|
||||
$C1 .#### ####. \
|
||||
$C1 .## ### \
|
||||
$C1 ## :## ### \
|
||||
$C1 # ## :## ## \
|
||||
$C1 ## ## ######. #### ###### :## ## \
|
||||
$C1 ## ## ##: ##: ## ## ### :## ### \
|
||||
$C1## ## ##: ##: ## :######## :## ## \
|
||||
$C1## ## ##: ##: ## ##. . :## #### \
|
||||
$C1## # ##: ##: #### #####: ## \
|
||||
$C1 ## \
|
||||
$C1 ###. ..o####. \
|
||||
$C1 ######oo... ..oo####### \
|
||||
$C1 o###############o "
|
||||
|
||||
#define ASCII_INTEL_NEW \
|
||||
"$C1 MMM oddl MMN \
|
||||
$C1 MMM dMMN MMN \
|
||||
$C1 ... .... ... dMMM.. .cc. NMN \
|
||||
$C1 MMM :MMMdWMMMMMX. dMMMMM, .XMMMMMMNo MMN \
|
||||
$C1 MMM :MMMp dMMM dMMX .NMW WMN. MMN \
|
||||
$C1 MMM :MMM WMM dMMK kMMXooooooNMMx MMN \
|
||||
$C1 MMM :MMM NMM dMMK dMMX MMN \
|
||||
$C1 MMM :MMM NMM dMMMoo OMM0....:Nx. MMN \
|
||||
$C1 MMM :WWW XWW lONMM 'xXMMMMNOc MMN "
|
||||
|
||||
#define ASCII_HYGON \
|
||||
"$C1 \
|
||||
$C1 \
|
||||
$C1 \
|
||||
$C1 ## ## ## ## ###### ###### ## # \
|
||||
$C1 ##....## ## ## ## ## ## #### # \
|
||||
$C1 ######## ## ## ##. ## ## # #### \
|
||||
$C1 ## ## ## *######. ###### # ## \
|
||||
$C1 \
|
||||
$C1 \
|
||||
$C1 \
|
||||
$C1 "
|
||||
|
||||
#define ASCII_SNAPD \
|
||||
" $C1@@$C2######## \
|
||||
$C1@@@@@$C2########### \
|
||||
$C1@@ @@@@@$C2################# \
|
||||
$C1@@@@@@@@@@$C2#################### \
|
||||
$C1@@@@@@@@@@@@$C2##################### \
|
||||
$C1@@@@@@@@@@@@@@@$C2#################### \
|
||||
$C1@@@@@@@@@@@@@@@@@$C2################### \
|
||||
$C1@@@@@@@@@@@@@@@@@@@@$C2################ \
|
||||
$C1@@@@@@@@@@@@@@@@@@@@$C2############# \
|
||||
$C1@@@@@@@@@@@@@@@@@@$C2############ \
|
||||
$C1@ @@@@@@@@@@@@@@@$C2########### \
|
||||
$C1@@@@@ @@@@@@@@@@@@@$C2########## \
|
||||
$C1@@@@@@@@@ @@@@@@@@@@@@$C2######## \
|
||||
$C1@@@@@@@@@ @@@@@@@@@@$C2####### \
|
||||
$C1@@@@@@@@@@@@@@@@$C2####### \
|
||||
$C1@@@@$C2########### "
|
||||
|
||||
#define ASCII_MTK \
|
||||
"$C1 ## ## ###### ###### # ### $C2@@@@@@ @@@@@@ @@ @@ \
|
||||
$C1 ### ### # # # # #### $C2@@ @ @@ @@ \
|
||||
$C1 ######## # ### # # # ## ## $C2@@ @ @@@ @@@@ \
|
||||
$C1 ## ### ## # # # # ## ## $C2@@ @ @@ @@ \
|
||||
$C1## ## ## ###### ##### # ## ## $C2@@ @@@@@@ @@ @@ "
|
||||
|
||||
#define ASCII_EXYNOS \
|
||||
"$C2 \
|
||||
$C2 \
|
||||
$C2 \
|
||||
$C1##$CR $C1##$CR $C1##$CR \
|
||||
$C1##$CR $C1##$CR \
|
||||
$C1##$CR \
|
||||
$C1##$CR $C1##$CR \
|
||||
$C1##$CR $C1##$CR $C1##$CR \
|
||||
$C2 \
|
||||
$C2 SAMSUNG \
|
||||
$C2 Exynos \
|
||||
$C2 \
|
||||
$C2 "
|
||||
|
||||
#define ASCII_KUNPENG \
|
||||
"$C2 . \
|
||||
$C2 .. \
|
||||
$C2 .## \
|
||||
$C1 .$CR $C2.###. \
|
||||
$C1 ..$CR $C2#####. \
|
||||
$C1 .#.$CR $C2.#######. \
|
||||
$C1 .####.$CR $C2.#######. \
|
||||
$C1 ..######*$CR $C2.#######. . \
|
||||
$C1 .#########*$CR $C2.#######* . \
|
||||
$C1 ######*$CR $C2.#######. .#. \
|
||||
$C1*#######*$CR $C2.#######. *##. \
|
||||
$C1 ##*$CR $C2.#######. ####### \
|
||||
$C2 ###.$CR $C1#####$C2 *### \
|
||||
$C1 *########## \
|
||||
$C1 *######## \
|
||||
$C1 #####. \
|
||||
$C1 *###. "
|
||||
|
||||
#define ASCII_KIRIN \
|
||||
"$C1 ####### \
|
||||
$C1 ##### #################### \
|
||||
$C1 ###################################### \
|
||||
$C1 ####################################### \
|
||||
$C1 ####################################### \
|
||||
$C1 ############################## \
|
||||
$C1 ########################## \
|
||||
$C1 ######################### \
|
||||
$C1 ######################## \
|
||||
$C1 ######################## \
|
||||
$C1 ######################### \
|
||||
$C1######################### "
|
||||
|
||||
#define ASCII_BROADCOM \
|
||||
"$C2 \
|
||||
$C2 ################ \
|
||||
$C2 ########################## \
|
||||
$C2 ################################ \
|
||||
$C2 ################$C1@@@@$C2################ \
|
||||
$C2 ################$C1@@@@@@$C2################ \
|
||||
$C2 #################$C1@@@@@@$C2################# \
|
||||
$C2#################$C1@@@@@@@@$C2################# \
|
||||
$C2#################$C1@@@@@@@@$C2################# \
|
||||
$C2################$C1@@@@$C2##$C1@@@@$C2################ \
|
||||
$C2################$C1@@@@$C2##$C1@@@@$C2################ \
|
||||
$C2###############$C1@@@@$C2####$C1@@@@$C2############### \
|
||||
$C1 @@@@@@@@@@$C2####$C1@@@@$C2####$C1@@@@$C2####$C1@@@@@@@@@@ \
|
||||
$C2 ######$C1@@@@@@@@@@$C2######$C1@@@@@@@@@@$C2###### \
|
||||
$C2 ################################## \
|
||||
$C2 ############################## \
|
||||
$C2 ######################## \
|
||||
$C2 ############### \
|
||||
$C2 "
|
||||
|
||||
#define ASCII_ARM \
|
||||
"$C1 ##### ## # ##### ## #### ###### \
|
||||
$C1 ### #### ### #### ### ### \
|
||||
$C1### ## ### ### ## ### \
|
||||
$C1 ### #### ### ### ## ### \
|
||||
$C1 ###### ## ### ### ## ### "
|
||||
|
||||
#define ASCII_IBM \
|
||||
"$C1######## ########## ###### ###### \
|
||||
$C1######## ########### ####### ####### \
|
||||
$C1 #### ### #### ###### ###### \
|
||||
$C1 #### ### ### ####### ####### \
|
||||
$C1 #### ######## ############### \
|
||||
$C1 #### ### ### #### ##### #### \
|
||||
$C1 #### ### #### #### ### #### \
|
||||
$C1######## ########### ###### # ###### \
|
||||
$C1######## ########## ###### ###### "
|
||||
|
||||
// inspired by the neofetch mac logo
|
||||
#define ASCII_APPLE \
|
||||
"$C1 .\"c. \
|
||||
$C1 ,xNMM. \
|
||||
$C1 .lMM\" \
|
||||
$C1 MM* \
|
||||
$C1 .;loddo;:. olloddol;. \
|
||||
$C1 cKMMMMMMMMMMNWMMMMMMMMMMM0: \
|
||||
$C1 .KMMMMMMMMMMMMMMMMMMMMMMMW* \
|
||||
$C1 XMMMMMMMMMMMMMMMMMMMMMMMX. \
|
||||
$C1;MMMMMMMMMMMMMMMMMMMMMMMM: \
|
||||
$C1:MMMMMMMMMMMMMMMMMMMMMMMM: \
|
||||
$C1.MMMMMMMMMMMMMMMMMMMMMMMMX. \
|
||||
$C1 kMMMMMMMMMMMMMMMMMMMMMMMMWd. \
|
||||
$C1 'XMMMMMMMMMMMMMMMMMMMMMMMMMMk \
|
||||
$C1 'XMMMMMMMMMMMMMMMMMMMMMMMMK. \
|
||||
$C1 kMMMMMMMMMMMMMMMMMMMMMMd \
|
||||
$C1 'KMMMMMMMWXXWMMMMMMMk. \
|
||||
$C1 \"cooc\"* \"*coo'\" "
|
||||
|
||||
#define ASCII_GOOGLE \
|
||||
"$C1 aaaaaaaa \
|
||||
$C1 .MMMMMMMMMMMMMMMM. \
|
||||
$C1 .MMMMMMMMMMMMMMMMMMMMM* \
|
||||
$C1 .MMMMMMMM** *MM* \
|
||||
$C2 MM$C1MMMMM. \
|
||||
$C2 *MMM$C1MM. \
|
||||
$C2*MMMMMM $C4lMMMMMMMMMMMMMMM* \
|
||||
$C2MMMMMMM $C4lMMMMMMMMMMMMMMMM \
|
||||
$C2*MMMMMM $C4lMMMMMMMMMMMMMMMd \
|
||||
$C2 MMMM$C3MMM. $C4*MMMMM. \
|
||||
$C2 MM$C3MMMMMM. $C4.MMMMMM. \
|
||||
$C3 *MMMMMMMMM*.......MMM$C4MMMMMM* \
|
||||
$C3 *MMMMMMMMMMMMMMMMMMMM$C4MM* \
|
||||
$C3 *MMMMMMMMMMMMMM* \
|
||||
$C3 ****** "
|
||||
|
||||
#define ASCII_ALLWINNER \
|
||||
"$C1 \
|
||||
$C1 ################# \
|
||||
$C1 .######## ##### #### \
|
||||
$C1 ###### ####### \
|
||||
$C1 #####. ## ..## ####. \
|
||||
$C1 .#### #### ##### #### \
|
||||
$C1 #### ## ### ###. ##### . \
|
||||
$C1#### ## ## #### .###### ####* . \
|
||||
$C1### ## ##.### ## #### .###### \
|
||||
$C1### #.## ### ##### ##### . \
|
||||
$C1### ### ### .### ### . \
|
||||
$C1 #### ### #### #. \
|
||||
$C1 #### #* \
|
||||
$C1 ##### ##. \
|
||||
$C1 ###########. \
|
||||
$C1 "
|
||||
|
||||
#define ASCII_ROCKCHIP \
|
||||
"$C1 \
|
||||
$C1 $C2## \
|
||||
$C1 ###### ## ## \
|
||||
$C1 ##. ### ##### ##### ## .## ##### ######. ## ##### \
|
||||
$C1 #######. ##. # #. ##### ##. ### ### # .## \
|
||||
$C1##. ###. ####. #### ### .## #### ### ### #.##### \
|
||||
$C1 ## \
|
||||
$C1 "
|
||||
|
||||
#define ASCII_RISCV \
|
||||
"$C1 \
|
||||
$C1 ************ \
|
||||
$C1 %%%%%%%%% *********** \
|
||||
$C1 %%%%%%%%%% ********** \
|
||||
$C1 %%%%%%%%% ********* \
|
||||
$C1 % ******** \
|
||||
$C1 %% .********* % \
|
||||
$C1 %%%% ******* %%% \
|
||||
$C1 %%%%%%. **** %%%%% \
|
||||
$C1 %%%%%%%%. %%%%%%% \
|
||||
$C1 \
|
||||
$C1 \
|
||||
$C1 ########### ## .######### ######### .## ## \
|
||||
$C1 ## ## ## ## ## ### ### \
|
||||
$C1 ########### ## ##########. ## #### .## ## \
|
||||
$C1 ## ### ## ##. ## ### ### \
|
||||
$C1 ## ### ## ##########. ########## ### \
|
||||
$C1 "
|
||||
|
||||
#define ASCII_SIFIVE \
|
||||
"$C1 ############################################## \
|
||||
$C1 ###########@@@@@@@@@@@@@@@@@@@@@@@@########### \
|
||||
$C1 #########@@@@@@@@@@@@@@@@@@@@@@@@@@@@######### \
|
||||
$C1 ########@@@@######################@@@@######## \
|
||||
$C1 #######@@@@########################@@@@####### \
|
||||
$C1 ######@@@@##########################@@@@###### \
|
||||
$C1 #####@@@@#######@@@@@@@@@@@@@@@@@@@@@@@@@##### \
|
||||
$C1 ####@@@@#######@@@@@@@@@@@@@@@@@@@@@@@@@@@#### \
|
||||
$C1 ###@@@@################################@@@@### \
|
||||
$C1 ##@@@@##################################@@@@## \
|
||||
$C1 #@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@#########@@@@# \
|
||||
$C1 #@@@@@@@@@@@@@@@@@@@@@@@@@@@@@###########@@@@# \
|
||||
$C1 ##@@@@@@############@@@@@@############@@@@@@## \
|
||||
$C1 ######@@@@@###########@@###########@@@@@###### \
|
||||
$C1 #########@@@@@@################@@@@@@######### \
|
||||
$C1 #############@@@@@##########@@@@@############# \
|
||||
$C1 ################@@@@@@##@@@@@@################ \
|
||||
$C1 ####################@@@@@@#################### \
|
||||
$C1 ############################################## "
|
||||
|
||||
#define ASCII_STARFIVE \
|
||||
"$C1 # \
|
||||
$C1 ########## \
|
||||
$C1 ######## ######## \
|
||||
$C1 ######## #### \
|
||||
$C1 ####### #### \
|
||||
$C1 #### ####### \
|
||||
$C1 #### ##### ####### \
|
||||
$C1 ####### ######## .## \
|
||||
$C1 ######## ######## \
|
||||
$C1 ### ########. ####### \
|
||||
$C1 ####### ##### #### \
|
||||
$C1 ######## #. #### \
|
||||
$C1 # #### ####### \
|
||||
$C1 ##### ####### \
|
||||
$C1 ######## ######## \
|
||||
$C1 ######### \
|
||||
$C1 # "
|
||||
|
||||
#define ASCII_SIPEED \
|
||||
"$C1 #################################### \
|
||||
$C1######@@################################ \
|
||||
$C1####@@##@@####@@@@@@@@@@@@@@@@########## \
|
||||
$C1######@@####@@@@@@@@@@@@@@@@@@########## \
|
||||
$C1#########@@@@########################### \
|
||||
$C1#######@@@@@@########################### \
|
||||
$C1#########@@@@########################### \
|
||||
$C1###########@@@@@@@@@@@@@@@############## \
|
||||
$C1##############@@@@@@@@@@@@@@@########### \
|
||||
$C1###########################@@@@@######## \
|
||||
$C1###########################@@@@@@####### \
|
||||
$C1###########################@@@@@######## \
|
||||
$C1##########@@@@@@@@@@@@@@@@@@@########### \
|
||||
$C1##########@@@@@@@@@@@@@@@@############## \
|
||||
$C1######################################## \
|
||||
$C1 #################################### "
|
||||
|
||||
#define ASCII_NVIDIA \
|
||||
"$C1 'cccccccccccccccccccccccccc \
|
||||
$C1 ;oooooooooooooooooooooooool \
|
||||
$C1 .:::. .oooooooooooooooooool \
|
||||
$C1 .:cll; ,c:::. cooooooooooooool \
|
||||
$C1 ,clo' ;. oolc: ooooooooooool \
|
||||
$C1.cloo ;cclo . .olc. coooooooool \
|
||||
$C1oooo :lo, ;ll; looc :oooooooool \
|
||||
$C1 oooc ool. ;oooc;clol :looooooooool \
|
||||
$C1 :ooc ,ol; ;oooooo. .cloo; loool \
|
||||
$C1 ool; .olc. ,:lool .lool \
|
||||
$C1 ool:. ,::::ccloo. :clooool \
|
||||
$C1 oolc::. ':cclooooooool \
|
||||
$C1 ;oooooooooooooooooooooooool \
|
||||
$C1 \
|
||||
$C1 \
|
||||
$C2######. ## ## ## ###### ## ### \
|
||||
$C2## ## ## ## ## ## ## ## #: :# \
|
||||
$C2## ## ## ## ## ## ## ## ####### \
|
||||
$C2## ## ### ## ###### ## ## ## "
|
||||
|
||||
#define ASCII_AMPERE \
|
||||
"$C1 \
|
||||
$C1 \
|
||||
$C1 ## \
|
||||
$C1 #### \
|
||||
$C1 ### ## \
|
||||
$C1 ### ### \
|
||||
$C1 ### ### \
|
||||
$C1 ### ### \
|
||||
$C1 ## ### \
|
||||
$C1 ####### ### ### \
|
||||
$C1 ###### ## ###### ### \
|
||||
$C1 #### ### ######## \
|
||||
$C1 #### ### #### \
|
||||
$C1 ### ### #### \
|
||||
$C1 ## ### ### \
|
||||
$C1 \
|
||||
$C1 "
|
||||
|
||||
#define ASCII_NXP \
|
||||
"$C1##### # $C2####### ####### $C3########## \
|
||||
$C1####### ## $C2####### ####### $C3############### \
|
||||
$C1########## #### $C2###### ###### $C3### ###### \
|
||||
$C1############ ##### $C2############ $C3##### ##### \
|
||||
$C1##### ####### ##### $C2########## $C3################### \
|
||||
$C1##### ######### $C2############## $C3############### \
|
||||
$C1##### ###### $C2###### ###### $C3#### \
|
||||
$C1##### ## $C2###### ###### $C3## "
|
||||
|
||||
#define ASCII_AMLOGIC \
|
||||
"$C1 .#####. ### ### \
|
||||
$C1 ######## ### \
|
||||
$C1 ####..### ########## ### ### ##### ### ### \
|
||||
$C1 .## #. ### ## ## ## ### ## ## ## ## ### ## \
|
||||
$C1 #### #.# ### ## ## ## ### ## ## ## ## ### ## \
|
||||
$C1#########.### ## ## ## ## ### ###### ## ### \
|
||||
$C1 ### \
|
||||
$C1 ### "
|
||||
|
||||
// --------------------- LONG LOGOS ------------------------- //
|
||||
#define ASCII_AMD_L \
|
||||
"$C1 \
|
||||
$C1 \
|
||||
$C1 \
|
||||
$C1 \
|
||||
$C1 \
|
||||
$C1 \
|
||||
$C1 @@@@ @@@ @@@ @@@@@@@@ $C2 ############ \
|
||||
$C1 @@@@@@ @@@@@ @@@@@ @@@ @@@ $C2 ########## \
|
||||
$C1 @@@ @@@ @@@@@@@@@@@@@ @@@ @@ $C2 # ##### \
|
||||
$C1 @@@ @@@ @@@ @@@ @@@ @@@ @@ $C2 ### ##### \
|
||||
$C1 @@@@@@@@@@@@ @@@ @@@ @@@ @@@ $C2######### ### \
|
||||
$C1 @@@ @@@ @@@ @@@ @@@@@@@@@ $C2######## ## \
|
||||
$C1 \
|
||||
$C1 \
|
||||
$C1 \
|
||||
$C1 \
|
||||
$C1 \
|
||||
$C1 \
|
||||
$C1 "
|
||||
|
||||
#define ASCII_INTEL_L \
|
||||
"$C1 ###############@ \
|
||||
$C1 ######@ ######@ \
|
||||
$C1 ###@ ###@ \
|
||||
$C1 ##@ ###@ \
|
||||
$C1 ##@ ##@ \
|
||||
$C1 ##@ ##@ \
|
||||
$C1 @ ##@ ##@ ##@ \
|
||||
$C1 #@ ##@ ########@ #####@ #####@ ##@ ##@ \
|
||||
$C1 #@ ##@ ##@ ##@ ##@ ###@ ###@ ##@ ##@ \
|
||||
$C1 #@ ##@ ##@ ##@ ##@ ##@ ##@ ##@ ##@ \
|
||||
$C1 #@ ##@ ##@ ##@ ##@ #########@ ##@ ###@ \
|
||||
$C1 #@ ##@ ##@ ##@ ##@ ##@ ##@ ####@ \
|
||||
$C1 #@ #@ ##@ ##@ ####@ ########@ #@ ##@ \
|
||||
$C1 ##@ \
|
||||
$C1 ##@ \
|
||||
$C1 ###@ ###@ \
|
||||
$C1 ####@ #########@ \
|
||||
$C1 #########@ ###############@ \
|
||||
$C1 ##############################@ "
|
||||
|
||||
#define ASCII_INTEL_L_NEW \
|
||||
" ####################################################### \
|
||||
####################################################### \
|
||||
####%%%#################@@@#####################@@@#### \
|
||||
####%%%#################@@@#####################@@@#### \
|
||||
########################@@@#####################@@@#### \
|
||||
####@@@##@@@#@@@@@@@####@@@@@@####@@@@@@@@@#####@@@#### \
|
||||
####@@@##@@@@@@@@@@@@###@@@@@@##@@@@#####@@@@###@@@#### \
|
||||
####@@@##@@@@#####@@@@##@@@####@@@@#######@@@@##@@@#### \
|
||||
####@@@##@@@#######@@@##@@@####@@@@@@@@@@@@@@@##@@@#### \
|
||||
####@@@##@@@#######@@@##@@@####@@@@#############@@@#### \
|
||||
####@@@##@@@#######@@@##@@@@@@##@@@@#####@@@@###@@@#### \
|
||||
####@@@##@@@#######@@@###@@@@@####@@@@@@@@@#####@@@#### \
|
||||
####################################################### \
|
||||
####################################################### "
|
||||
|
||||
#define ASCII_ARM_L \
|
||||
"$C1 ############ ########## #### ####### ######## \
|
||||
$C1 ############### ######### ######################## \
|
||||
$C1 #### #### #### ##### ######## ##### \
|
||||
$C1#### #### #### #### ###### #### \
|
||||
$C1#### #### #### #### #### #### \
|
||||
$C1 #### ##### #### #### #### #### \
|
||||
$C1 ############### #### #### #### #### \
|
||||
$C1 ######## #### #### #### #### #### "
|
||||
|
||||
#define ASCII_IBM_L \
|
||||
"$C1 ############ ################ ########## ########## \
|
||||
$C1 \
|
||||
$C1 ############ ################## ############ ############ \
|
||||
$C1 \
|
||||
$C1 ###### ###### ###### #################### \
|
||||
$C1 \
|
||||
$C1 ###### ############## #################### \
|
||||
$C1 \
|
||||
$C1 ###### ###### ###### ##### ###### ##### \
|
||||
$C1 \
|
||||
$C1 ############ ################## ######### #### ######### \
|
||||
$C1 \
|
||||
$C1 ############ ################ ######### ## ######### "
|
||||
|
||||
#define ASCII_SIFIVE_L \
|
||||
"$C1 ################################################### \
|
||||
$C1 ###########@@@@@@@@@@@@@@@@@@@@@@@@@@@@############ \
|
||||
$C1 ##########@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@########### \
|
||||
$C1 #########@@@@@#######################@@@@########## \
|
||||
$C1 ########@@@@@#########################@@@@######### \
|
||||
$C1 #######@@@@@###########################@@@@######## \
|
||||
$C1 ######@@@@@########@@@@@@@@@@@@@@@@@@@@@@@@@####### \
|
||||
$C1 #####@@@@@########@@@@@@@@@@@@@@@@@@@@@@@@@@@###### \
|
||||
$C1 ####@@@@@################################@@@@@##### \
|
||||
$C1 ###@@@@@##################################@@@@@#### \
|
||||
$C1 ##@@@@@####################################@@@@@### \
|
||||
$C1 ##@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@#########@@@@### \
|
||||
$C1 ##@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@############@@@@### \
|
||||
$C1 ####@@@@@#############@@@@@@@############@@@@@##### \
|
||||
$C1 #######@@@@@@############@############@@@@@@####### \
|
||||
$C1 ##########@@@@@@###################@@@@@@########## \
|
||||
$C1 ##############@@@@@@###########@@@@@@############## \
|
||||
$C1 #################@@@@@@#####@@@@@@################# \
|
||||
$C1 ####################@@@@@@@@@@@#################### \
|
||||
$C1 ########################@@@######################## \
|
||||
$C1 ################################################### "
|
||||
|
||||
#define ASCII_STARFIVE_L \
|
||||
"$C1 ####### \
|
||||
$C1 ################. \
|
||||
$C1 ############ ########### \
|
||||
$C1 ############ ##########. \
|
||||
$C1 ############ # ###### \
|
||||
$C1 ########### ##### ## \
|
||||
$C1 #######. ########## \
|
||||
$C1 ###### ### *########### \
|
||||
$C1 ###### #######. ########## \
|
||||
$C1 ######### ############ ###### \
|
||||
$C1 ###########. ###########* # \
|
||||
$C1 ############ ############ \
|
||||
$C1 # ############. .########### \
|
||||
$C1 ###### ########### ######### \
|
||||
$C1 ########## .######, ##### \
|
||||
$C1 ############ ##. #####. \
|
||||
$C1 ######### ######## \
|
||||
$C1 ## ##### ##########. \
|
||||
$C1 ####### # ############ \
|
||||
$C1 ########### ###########. \
|
||||
$C1 ###########. ############ \
|
||||
$C1 ################ \
|
||||
$C1 ####### "
|
||||
|
||||
#define ASCII_NVIDIA_L \
|
||||
"$C1 MMMMMMMMMMMMMMMMMMMMMMMMMMMMMM \
|
||||
$C1 MMMMMMMMMMMMMMMMMMMMMMMMMMMMMM \
|
||||
$C1 .:: 'MMMMMMMMMMMMMMMMMMMMMMMMM \
|
||||
$C1 ccllooo;:;. ;MMMMMMMMMMMMMMMMMM \
|
||||
$C1 cloc :ooollcc: :MMMMMMMMMMMMMMM \
|
||||
$C1 cloc :ccl; lolc, ;MMMMMMMMMMMM \
|
||||
$C1.cloo: :clo ;c: .ool; MMMMMMMMMMM \
|
||||
$C1 ooo: ooo :ool, .cloo. ;lMMMMMMMMMMM \
|
||||
$C1 ooo: ooc :ooooccooo. :MMMM lMMMMMMM \
|
||||
$C1 ooc. ool: :oooooo' ,cloo. MMMM \
|
||||
$C1 ool:. olc: .:cloo. :MMMM \
|
||||
$C1 olc, ;:::cccloo. :MMMMMMMM \
|
||||
$C1 olcc::; ,:ccloMMMMMMMMM \
|
||||
$C1 :......oMMMMMMMMMMMMMMMMMMMMMM \
|
||||
$C1 :lllMMMMMMMMMMMMMMMMMMMMMMMMMM "
|
||||
|
||||
typedef struct ascii_logo asciiL;
|
||||
|
||||
// +-----------------------------------------------------------------------------------------------------------------+
|
||||
// | LOGO | W | H | REPLACE | COLORS LOGO (>0 && <10) | COLORS TEXT (=2) |
|
||||
// +-----------------------------------------------------------------------------------------------------------------+
|
||||
asciiL logo_amd = { ASCII_AMD, 39, 15, false, {C_FG_WHITE, C_FG_GREEN}, {C_FG_WHITE, C_FG_GREEN} };
|
||||
asciiL logo_intel = { ASCII_INTEL, 48, 14, false, {C_FG_CYAN}, {C_FG_CYAN, C_FG_WHITE} };
|
||||
asciiL logo_intel_new = { ASCII_INTEL_NEW, 51, 9, false, {C_FG_CYAN}, {C_FG_CYAN, C_FG_WHITE} };
|
||||
asciiL logo_hygon = { ASCII_HYGON, 51, 11, false, {C_FG_RED}, {C_FG_RED, C_FG_WHITE} };
|
||||
asciiL logo_snapd = { ASCII_SNAPD, 39, 16, false, {C_FG_RED, C_FG_WHITE}, {C_FG_RED, C_FG_WHITE} };
|
||||
asciiL logo_mtk = { ASCII_MTK, 59, 5, false, {C_FG_BLUE, C_FG_YELLOW}, {C_FG_BLUE, C_FG_YELLOW} };
|
||||
asciiL logo_exynos = { ASCII_EXYNOS, 22, 13, true, {C_BG_BLUE, C_FG_WHITE}, {C_FG_BLUE, C_FG_WHITE} };
|
||||
asciiL logo_kirin = { ASCII_KIRIN, 53, 12, false, {C_FG_RED}, {C_FG_WHITE, C_FG_RED} };
|
||||
asciiL logo_kunpeng = { ASCII_KUNPENG, 48, 17, false, {C_FG_RED, C_FG_WHITE}, {C_FG_WHITE, C_FG_RED} };
|
||||
asciiL logo_broadcom = { ASCII_BROADCOM, 44, 19, false, {C_FG_WHITE, C_FG_RED}, {C_FG_WHITE, C_FG_RED} };
|
||||
asciiL logo_arm = { ASCII_ARM, 42, 5, false, {C_FG_CYAN}, {C_FG_WHITE, C_FG_CYAN} };
|
||||
asciiL logo_ibm = { ASCII_IBM, 42, 9, false, {C_FG_CYAN, C_FG_WHITE}, {C_FG_CYAN, C_FG_WHITE} };
|
||||
asciiL logo_apple = { ASCII_APPLE, 32, 17, false, {C_FG_WHITE}, {C_FG_CYAN, C_FG_B_WHITE} };
|
||||
asciiL logo_google = { ASCII_GOOGLE, 35, 15, false, {C_FG_RED, C_FG_YELLOW, C_FG_GREEN, C_FG_BLUE}, {C_FG_BLUE, C_FG_B_WHITE} };
|
||||
asciiL logo_allwinner = { ASCII_ALLWINNER, 47, 16, false, {C_FG_CYAN}, {C_FG_B_BLACK, C_FG_B_CYAN } };
|
||||
asciiL logo_rockchip = { ASCII_ROCKCHIP, 58, 8, false, {C_FG_CYAN, C_FG_YELLOW}, {C_FG_CYAN, C_FG_YELLOW} };
|
||||
asciiL logo_riscv = { ASCII_RISCV, 63, 18, false, {C_FG_CYAN, C_FG_YELLOW}, {C_FG_CYAN, C_FG_YELLOW} };
|
||||
asciiL logo_sifive = { ASCII_SIFIVE, 48, 19, true, {C_BG_WHITE, C_BG_BLACK}, {C_FG_WHITE, C_FG_BLUE} };
|
||||
asciiL logo_starfive = { ASCII_STARFIVE, 33, 17, false, {C_FG_WHITE}, {C_FG_WHITE, C_FG_BLUE} };
|
||||
asciiL logo_sipeed = { ASCII_SIPEED, 41, 16, true, {C_BG_RED, C_BG_WHITE}, {C_FG_RED, C_FG_WHITE} };
|
||||
asciiL logo_nvidia = { ASCII_NVIDIA, 45, 19, false, {C_FG_GREEN, C_FG_WHITE}, {C_FG_WHITE, C_FG_GREEN} };
|
||||
asciiL logo_ampere = { ASCII_AMPERE, 50, 17, false, {C_FG_RED}, {C_FG_WHITE, C_FG_RED} };
|
||||
asciiL logo_nxp = { ASCII_NXP, 55, 8, false, {C_FG_YELLOW, C_FG_CYAN, C_FG_GREEN}, {C_FG_CYAN, C_FG_WHITE} };
|
||||
asciiL logo_amlogic = { ASCII_AMLOGIC, 58, 8, false, {C_FG_BLUE}, {C_FG_BLUE, C_FG_B_WHITE} };
|
||||
|
||||
// Long variants | ----------------------------------------------------------------------------------------------------------------|
|
||||
asciiL logo_amd_l = { ASCII_AMD_L, 62, 19, true, {C_BG_WHITE, C_BG_GREEN}, {C_FG_WHITE, C_FG_GREEN} };
|
||||
asciiL logo_intel_l = { ASCII_INTEL_L, 62, 19, true, {C_BG_CYAN, C_BG_WHITE}, {C_FG_CYAN, C_FG_WHITE} };
|
||||
asciiL logo_intel_l_new = { ASCII_INTEL_L_NEW, 57, 14, true, {C_BG_CYAN, C_BG_WHITE, C_BG_BLUE}, {C_FG_CYAN, C_FG_WHITE} };
|
||||
asciiL logo_arm_l = { ASCII_ARM_L, 60, 8, true, {C_BG_CYAN}, {C_FG_WHITE, C_FG_CYAN} };
|
||||
asciiL logo_ibm_l = { ASCII_IBM_L, 62, 13, true, {C_BG_CYAN, C_FG_WHITE}, {C_FG_CYAN, C_FG_WHITE} };
|
||||
asciiL logo_starfive_l = { ASCII_STARFIVE_L, 50, 22, false, {C_FG_WHITE}, {C_FG_WHITE, C_FG_BLUE} };
|
||||
asciiL logo_sifive_l = { ASCII_SIFIVE_L, 53, 21, true, {C_BG_WHITE, C_BG_BLACK}, {C_FG_WHITE, C_FG_CYAN} };
|
||||
asciiL logo_nvidia_l = { ASCII_NVIDIA_L, 50, 15, false, {C_FG_GREEN, C_FG_WHITE}, {C_FG_WHITE, C_FG_GREEN} };
|
||||
asciiL logo_unknown = { NULL, 0, 0, false, {COLOR_NONE}, {COLOR_NONE, COLOR_NONE} };
|
||||
|
||||
#endif
|
||||
|
||||
152
src/common/cpu.c
Normal file → Executable file
152
src/common/cpu.c
Normal file → Executable file
@@ -9,15 +9,11 @@
|
||||
|
||||
#ifdef ARCH_X86
|
||||
#include "../x86/uarch.h"
|
||||
#include "../x86/apic.h"
|
||||
#elif ARCH_PPC
|
||||
#include "../ppc/uarch.h"
|
||||
#elif ARCH_ARM
|
||||
#include "../arm/uarch.h"
|
||||
#elif ARCH_RISCV
|
||||
#include "../riscv/uarch.h"
|
||||
#endif
|
||||
|
||||
#define STRING_UNKNOWN "Unknown"
|
||||
#define STRING_YES "Yes"
|
||||
#define STRING_NO "No"
|
||||
#define STRING_NONE "None"
|
||||
@@ -35,25 +31,12 @@ int64_t get_freq(struct frequency* freq) {
|
||||
}
|
||||
|
||||
#ifdef ARCH_X86
|
||||
int64_t get_freq_pp(struct frequency* freq) {
|
||||
return freq->max_pp;
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(ARCH_X86) || defined(ARCH_PPC)
|
||||
char* get_str_cpu_name(struct cpuInfo* cpu, bool fcpuname) {
|
||||
#ifdef ARCH_X86
|
||||
if(!fcpuname) {
|
||||
return get_str_cpu_name_abbreviated(cpu);
|
||||
}
|
||||
#elif ARCH_PPC
|
||||
UNUSED(fcpuname);
|
||||
#endif
|
||||
char* get_str_cpu_name(struct cpuInfo* cpu) {
|
||||
return cpu->cpu_name;
|
||||
}
|
||||
|
||||
char* get_str_sockets(struct topology* topo) {
|
||||
char* string = emalloc(sizeof(char) * 2);
|
||||
char* string = malloc(sizeof(char) * 2);
|
||||
int32_t sanity_ret = snprintf(string, 2, "%d", topo->sockets);
|
||||
if(sanity_ret < 0) {
|
||||
printBug("get_str_sockets: snprintf returned a negative value for input: '%d'", topo->sockets);
|
||||
@@ -68,58 +51,71 @@ uint32_t get_nsockets(struct topology* topo) {
|
||||
#endif
|
||||
|
||||
int32_t get_value_as_smallest_unit(char ** str, uint32_t value) {
|
||||
int32_t ret;
|
||||
int max_len = 10; // Max is 8 for digits, 2 for units
|
||||
*str = emalloc(sizeof(char)* (max_len + 1));
|
||||
int32_t sanity_ret;
|
||||
*str = malloc(sizeof(char)* 11); //8 for digits, 2 for units
|
||||
|
||||
if(value/1024 >= 1024)
|
||||
ret = snprintf(*str, max_len, "%.4g"STRING_MEGABYTES, (double)value/(1<<20));
|
||||
sanity_ret = snprintf(*str, 10,"%.4g"STRING_MEGABYTES, (double)value/(1<<20));
|
||||
else
|
||||
ret = snprintf(*str, max_len, "%.4g"STRING_KILOBYTES, (double)value/(1<<10));
|
||||
sanity_ret = snprintf(*str, 10,"%.4g"STRING_KILOBYTES, (double)value/(1<<10));
|
||||
|
||||
return ret;
|
||||
return sanity_ret;
|
||||
}
|
||||
|
||||
// String functions
|
||||
char* get_str_cache_two(int32_t cache_size, uint32_t physical_cores) {
|
||||
// 4 for digits, 2 for units, 2 for ' (', 3 digits, 2 for units and 7 for ' Total)'
|
||||
uint32_t max_size = 4+2 + 2 + 4+2 + 7 + 1;
|
||||
int32_t sanity_ret;
|
||||
char* string = malloc(sizeof(char) * max_size);
|
||||
char* tmp1;
|
||||
char* tmp2;
|
||||
int32_t tmp1_len = get_value_as_smallest_unit(&tmp1, cache_size);
|
||||
int32_t tmp2_len = get_value_as_smallest_unit(&tmp2, cache_size * physical_cores);
|
||||
|
||||
// tmp1_len for first output, 2 for ' (', tmp2_len for second output and 7 for ' Total)'
|
||||
uint32_t size = tmp1_len + 2 + tmp2_len + 7 + 1;
|
||||
char* string = emalloc(sizeof(char) * size);
|
||||
|
||||
if(tmp1_len < 0) {
|
||||
printBug("get_value_as_smallest_unit: snprintf failed for input: %d\n", cache_size);
|
||||
printBug("get_value_as_smallest_unit: snprintf returned a negative value for input: %d\n", cache_size);
|
||||
return NULL;
|
||||
}
|
||||
if(tmp2_len < 0) {
|
||||
printBug("get_value_as_smallest_unit: snprintf failed for input: %d\n", cache_size * physical_cores);
|
||||
printBug("get_value_as_smallest_unit: snprintf returned a negative value for input: %d\n", cache_size * physical_cores);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if(snprintf(string, size, "%s (%s Total)", tmp1, tmp2) < 0) {
|
||||
printBug("get_str_cache_two: snprintf failed for input: '%s' and '%s'\n", tmp1, tmp2);
|
||||
uint32_t size = tmp1_len + 2 + tmp2_len + 7 + 1;
|
||||
sanity_ret = snprintf(string, size, "%s (%s Total)", tmp1, tmp2);
|
||||
|
||||
if(sanity_ret < 0) {
|
||||
printBug("get_str_cache_two: snprintf returned a negative value for input: '%s' and '%s'\n", tmp1, tmp2);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
free(tmp1);
|
||||
free(tmp2);
|
||||
|
||||
return string;
|
||||
}
|
||||
|
||||
char* get_str_cache_one(int32_t cache_size) {
|
||||
char* string;
|
||||
int32_t str_len = get_value_as_smallest_unit(&string, cache_size);
|
||||
// 4 for digits, 2 for units, 2 for ' (', 3 digits, 2 for units and 7 for ' Total)'
|
||||
uint32_t max_size = 4+2 + 1;
|
||||
int32_t sanity_ret;
|
||||
char* string = malloc(sizeof(char) * max_size);
|
||||
char* tmp;
|
||||
int32_t tmp_len = get_value_as_smallest_unit(&tmp, cache_size);
|
||||
|
||||
if(str_len < 0) {
|
||||
printBug("get_value_as_smallest_unit: snprintf failed for input: %d", cache_size);
|
||||
if(tmp_len < 0) {
|
||||
printBug("get_value_as_smallest_unit: snprintf returned a negative value for input: %d", cache_size);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
uint32_t size = tmp_len + 1;
|
||||
sanity_ret = snprintf(string, size, "%s", tmp);
|
||||
|
||||
if(sanity_ret < 0) {
|
||||
printBug("get_str_cache_one: snprintf returned a negative value for input: '%s'", tmp);
|
||||
return NULL;
|
||||
}
|
||||
free(tmp);
|
||||
return string;
|
||||
}
|
||||
|
||||
@@ -151,87 +147,21 @@ char* get_str_l3(struct cache* cach) {
|
||||
|
||||
char* get_str_freq(struct frequency* freq) {
|
||||
//Max 3 digits and 3 for '(M/G)Hz' plus 1 for '\0'
|
||||
uint32_t size = (1+5+1+3+1);
|
||||
uint32_t size = (4+3+1);
|
||||
assert(strlen(STRING_UNKNOWN)+1 <= size);
|
||||
char* string = ecalloc(size, sizeof(char));
|
||||
char* string = malloc(sizeof(char)*size);
|
||||
memset(string, 0, sizeof(char)*size);
|
||||
|
||||
if(freq->max == UNKNOWN_DATA || freq->max < 0) {
|
||||
if(freq->max == UNKNOWN_FREQ || freq->max < 0)
|
||||
snprintf(string,strlen(STRING_UNKNOWN)+1,STRING_UNKNOWN);
|
||||
}
|
||||
else if(freq->max >= 1000) {
|
||||
if (freq->measured)
|
||||
snprintf(string,size,"~%.3f "STRING_GIGAHERZ,(float)(freq->max)/1000);
|
||||
else
|
||||
snprintf(string,size,"%.3f "STRING_GIGAHERZ,(float)(freq->max)/1000);
|
||||
}
|
||||
else {
|
||||
if (freq->measured)
|
||||
snprintf(string,size,"~%d "STRING_MEGAHERZ,freq->max);
|
||||
else if(freq->max >= 1000)
|
||||
snprintf(string,size,"%.2f"STRING_GIGAHERZ,(float)(freq->max)/1000);
|
||||
else
|
||||
snprintf(string,size,"%d"STRING_MEGAHERZ,freq->max);
|
||||
}
|
||||
|
||||
return string;
|
||||
}
|
||||
|
||||
char* get_str_peak_performance(int64_t flops) {
|
||||
char* str;
|
||||
|
||||
if(flops == -1) {
|
||||
str = emalloc(sizeof(char) * (strlen(STRING_UNKNOWN) + 1));
|
||||
strncpy(str, STRING_UNKNOWN, strlen(STRING_UNKNOWN) + 1);
|
||||
return str;
|
||||
}
|
||||
|
||||
// 7 for digits (e.g, XXXX.XX), 7 for XFLOP/s
|
||||
double flopsd = (double) flops;
|
||||
uint32_t max_size = 7+1+7+1;
|
||||
str = ecalloc(max_size, sizeof(char));
|
||||
|
||||
if(flopsd >= (double)1000000000000.0)
|
||||
snprintf(str, max_size, "%.2f TFLOP/s", flopsd/1000000000000);
|
||||
else if(flopsd >= 1000000000.0)
|
||||
snprintf(str, max_size, "%.2f GFLOP/s", flopsd/1000000000);
|
||||
else
|
||||
snprintf(str, max_size, "%.2f MFLOP/s", flopsd/1000000);
|
||||
|
||||
return str;
|
||||
}
|
||||
|
||||
void init_topology_struct(struct topology* topo, struct cache* cach) {
|
||||
topo->total_cores = 0;
|
||||
topo->cach = cach;
|
||||
#if defined(ARCH_X86) || defined(ARCH_PPC)
|
||||
topo->physical_cores = 0;
|
||||
topo->logical_cores = 0;
|
||||
topo->smt_supported = 0;
|
||||
topo->sockets = 0;
|
||||
#ifdef ARCH_X86
|
||||
topo->smt_available = 0;
|
||||
topo->apic = ecalloc(1, sizeof(struct apic));
|
||||
#endif
|
||||
#endif
|
||||
}
|
||||
|
||||
void init_cache_struct(struct cache* cach) {
|
||||
cach->L1i = emalloc(sizeof(struct cach));
|
||||
cach->L1d = emalloc(sizeof(struct cach));
|
||||
cach->L2 = emalloc(sizeof(struct cach));
|
||||
cach->L3 = emalloc(sizeof(struct cach));
|
||||
|
||||
cach->cach_arr = emalloc(sizeof(struct cach*) * 4);
|
||||
cach->cach_arr[0] = cach->L1i;
|
||||
cach->cach_arr[1] = cach->L1d;
|
||||
cach->cach_arr[2] = cach->L2;
|
||||
cach->cach_arr[3] = cach->L3;
|
||||
|
||||
cach->max_cache_level = 0;
|
||||
cach->L1i->exists = false;
|
||||
cach->L1d->exists = false;
|
||||
cach->L2->exists = false;
|
||||
cach->L3->exists = false;
|
||||
}
|
||||
|
||||
void free_cache_struct(struct cache* cach) {
|
||||
for(int i=0; i < 4; i++) free(cach->cach_arr[i]);
|
||||
free(cach->cach_arr);
|
||||
|
||||
@@ -8,23 +8,16 @@ enum {
|
||||
// ARCH_X86
|
||||
CPU_VENDOR_INTEL,
|
||||
CPU_VENDOR_AMD,
|
||||
CPU_VENDOR_HYGON,
|
||||
// ARCH_ARM
|
||||
CPU_VENDOR_ARM,
|
||||
CPU_VENDOR_APPLE,
|
||||
CPU_VENDOR_BROADCOM,
|
||||
CPU_VENDOR_CAVIUM,
|
||||
CPU_VENDOR_NVIDIA,
|
||||
CPU_VENDOR_APM,
|
||||
CPU_VENDOR_QUALCOMM,
|
||||
CPU_VENDOR_HUAWEI,
|
||||
CPU_VENDOR_HUAWUEI,
|
||||
CPU_VENDOR_SAMSUNG,
|
||||
CPU_VENDOR_MARVELL,
|
||||
CPU_VENDOR_PHYTIUM,
|
||||
// ARCH_RISCV
|
||||
CPU_VENDOR_RISCV,
|
||||
CPU_VENDOR_SIFIVE,
|
||||
CPU_VENDOR_THEAD,
|
||||
// OTHERS
|
||||
CPU_VENDOR_UNKNOWN,
|
||||
CPU_VENDOR_INVALID
|
||||
@@ -33,24 +26,14 @@ enum {
|
||||
enum {
|
||||
HV_VENDOR_KVM,
|
||||
HV_VENDOR_QEMU,
|
||||
HV_VENDOR_VBOX,
|
||||
HV_VENDOR_HYPERV,
|
||||
HV_VENDOR_VMWARE,
|
||||
HV_VENDOR_XEN,
|
||||
HV_VENDOR_PARALLELS,
|
||||
HV_VENDOR_PHYP,
|
||||
HV_VENDOR_BHYVE,
|
||||
HV_VENDOR_APPLEVZ,
|
||||
HV_VENDOR_INVALID
|
||||
};
|
||||
|
||||
enum {
|
||||
CORE_TYPE_EFFICIENCY,
|
||||
CORE_TYPE_PERFORMANCE,
|
||||
CORE_TYPE_UNKNOWN
|
||||
};
|
||||
|
||||
#define UNKNOWN_DATA -1
|
||||
#define UNKNOWN_FREQ -1
|
||||
#define CPU_NAME_MAX_LENGTH 64
|
||||
|
||||
typedef int32_t VENDOR;
|
||||
@@ -58,13 +41,6 @@ typedef int32_t VENDOR;
|
||||
struct frequency {
|
||||
int32_t base;
|
||||
int32_t max;
|
||||
// Indicates if max frequency was measured
|
||||
bool measured;
|
||||
#ifdef ARCH_X86
|
||||
// Max frequency when running vectorized code.
|
||||
// Used only for peak performance computation.
|
||||
int32_t max_pp;
|
||||
#endif
|
||||
};
|
||||
|
||||
struct hypervisor {
|
||||
@@ -93,17 +69,14 @@ struct cache {
|
||||
struct topology {
|
||||
int32_t total_cores;
|
||||
struct cache* cach;
|
||||
#if defined(ARCH_X86) || defined(ARCH_PPC)
|
||||
int32_t physical_cores;
|
||||
int32_t logical_cores;
|
||||
uint32_t sockets;
|
||||
uint32_t smt_supported; // Number of SMT that CPU supports (equal to smt_available if SMT is enabled)
|
||||
#ifdef ARCH_X86
|
||||
uint32_t physical_cores;
|
||||
uint32_t logical_cores;
|
||||
uint32_t smt_available; // Number of SMT that is currently enabled
|
||||
int32_t total_cores_module; // Total cores in the current module (only makes sense in hybrid archs, like ADL)
|
||||
uint32_t smt_supported; // Number of SMT that CPU supports (equal to smt_available if SMT is enabled)
|
||||
uint32_t sockets;
|
||||
struct apic* apic;
|
||||
#endif
|
||||
#endif
|
||||
};
|
||||
|
||||
struct features {
|
||||
@@ -122,24 +95,14 @@ struct features {
|
||||
bool FMA3;
|
||||
bool FMA4;
|
||||
bool SHA;
|
||||
#elif ARCH_PPC
|
||||
bool altivec;
|
||||
#elif ARCH_ARM
|
||||
bool NEON;
|
||||
bool SHA1;
|
||||
bool SHA2;
|
||||
bool CRC32;
|
||||
bool SVE;
|
||||
bool SVE2;
|
||||
uint64_t cntb;
|
||||
#endif
|
||||
};
|
||||
|
||||
struct extensions {
|
||||
char* str;
|
||||
uint64_t mask;
|
||||
};
|
||||
|
||||
struct cpuInfo {
|
||||
VENDOR cpu_vendor;
|
||||
struct uarch* arch;
|
||||
@@ -147,69 +110,38 @@ struct cpuInfo {
|
||||
struct frequency* freq;
|
||||
struct cache* cach;
|
||||
struct topology* topo;
|
||||
int64_t peak_performance;
|
||||
|
||||
// Similar but not exactly equal
|
||||
// to struct features
|
||||
#ifdef ARCH_RISCV
|
||||
struct extensions* ext;
|
||||
#else
|
||||
struct features* feat;
|
||||
#endif
|
||||
|
||||
#if defined(ARCH_X86) || defined(ARCH_PPC)
|
||||
// CPU name from model
|
||||
char* cpu_name;
|
||||
#endif
|
||||
|
||||
#ifdef ARCH_X86
|
||||
// CPU name from model
|
||||
char* cpu_name;
|
||||
// Max cpuids levels
|
||||
uint32_t maxLevels;
|
||||
// Max cpuids extended levels
|
||||
uint32_t maxExtendedLevels;
|
||||
// Topology Extensions (AMD only)
|
||||
bool topology_extensions;
|
||||
// Hybrid Flag (Intel only)
|
||||
bool hybrid_flag;
|
||||
// Core Type (P/E)
|
||||
uint32_t core_type;
|
||||
#elif ARCH_PPC
|
||||
uint32_t pvr;
|
||||
#elif ARCH_ARM
|
||||
// Main ID register
|
||||
uint32_t midr;
|
||||
#endif
|
||||
|
||||
#if defined(ARCH_ARM) || defined(ARCH_RISCV)
|
||||
#ifdef ARCH_ARM
|
||||
struct system_on_chip* soc;
|
||||
#endif
|
||||
|
||||
#if defined(ARCH_X86) || defined(ARCH_ARM)
|
||||
// If SoC contains more than one CPU and they
|
||||
// are different, the others will be stored in
|
||||
// the next_cpu field
|
||||
struct cpuInfo* next_cpu;
|
||||
uint8_t num_cpus;
|
||||
#ifdef ARCH_X86
|
||||
// The index of the first core in the module
|
||||
uint32_t first_core_id;
|
||||
// The index of this module
|
||||
uint32_t module_id;
|
||||
#endif
|
||||
#endif
|
||||
};
|
||||
|
||||
#if defined(ARCH_X86) || defined(ARCH_PPC)
|
||||
char* get_str_cpu_name(struct cpuInfo* cpu, bool fcpuname);
|
||||
#ifdef ARCH_X86
|
||||
char* get_str_cpu_name(struct cpuInfo* cpu);
|
||||
char* get_str_sockets(struct topology* topo);
|
||||
uint32_t get_nsockets(struct topology* topo);
|
||||
#endif
|
||||
|
||||
VENDOR get_cpu_vendor(struct cpuInfo* cpu);
|
||||
int64_t get_freq(struct frequency* freq);
|
||||
#ifdef ARCH_X86
|
||||
int64_t get_freq_pp(struct frequency* freq);
|
||||
#endif
|
||||
|
||||
char* get_str_aes(struct cpuInfo* cpu);
|
||||
char* get_str_sha(struct cpuInfo* cpu);
|
||||
@@ -218,10 +150,6 @@ char* get_str_l1d(struct cache* cach);
|
||||
char* get_str_l2(struct cache* cach);
|
||||
char* get_str_l3(struct cache* cach);
|
||||
char* get_str_freq(struct frequency* freq);
|
||||
char* get_str_peak_performance(int64_t flops);
|
||||
|
||||
void init_topology_struct(struct topology* topo, struct cache* cach);
|
||||
void init_cache_struct(struct cache* cach);
|
||||
|
||||
void free_cache_struct(struct cache* cach);
|
||||
void free_freq_struct(struct frequency* freq);
|
||||
|
||||
@@ -1,195 +0,0 @@
|
||||
#ifdef __linux__
|
||||
|
||||
#define _GNU_SOURCE
|
||||
|
||||
#include <time.h>
|
||||
#include <stdio.h>
|
||||
#include <stdint.h>
|
||||
#include <string.h>
|
||||
#include <errno.h>
|
||||
#include <unistd.h>
|
||||
#include <asm/unistd.h>
|
||||
#include <sys/ioctl.h>
|
||||
#include <linux/perf_event.h>
|
||||
|
||||
#include "global.h"
|
||||
#include "cpu.h"
|
||||
|
||||
static long
|
||||
perf_event_open(struct perf_event_attr *hw_event, pid_t pid,
|
||||
int cpu, int group_fd, unsigned long flags) {
|
||||
int ret;
|
||||
ret = syscall(__NR_perf_event_open, hw_event, pid, cpu,
|
||||
group_fd, flags);
|
||||
return ret;
|
||||
}
|
||||
|
||||
#define INSERT_ASM_ONCE __asm volatile("nop");
|
||||
#define INSERT_ASM_10_TIMES \
|
||||
INSERT_ASM_ONCE \
|
||||
INSERT_ASM_ONCE \
|
||||
INSERT_ASM_ONCE \
|
||||
INSERT_ASM_ONCE \
|
||||
INSERT_ASM_ONCE \
|
||||
INSERT_ASM_ONCE \
|
||||
INSERT_ASM_ONCE \
|
||||
INSERT_ASM_ONCE \
|
||||
INSERT_ASM_ONCE \
|
||||
INSERT_ASM_ONCE \
|
||||
|
||||
#define INSERT_ASM_100_TIMES \
|
||||
INSERT_ASM_10_TIMES \
|
||||
INSERT_ASM_10_TIMES \
|
||||
INSERT_ASM_10_TIMES \
|
||||
INSERT_ASM_10_TIMES \
|
||||
INSERT_ASM_10_TIMES \
|
||||
INSERT_ASM_10_TIMES \
|
||||
INSERT_ASM_10_TIMES \
|
||||
INSERT_ASM_10_TIMES \
|
||||
INSERT_ASM_10_TIMES \
|
||||
INSERT_ASM_10_TIMES
|
||||
|
||||
#define INSERT_ASM_1000_TIMES \
|
||||
INSERT_ASM_100_TIMES \
|
||||
INSERT_ASM_100_TIMES \
|
||||
INSERT_ASM_100_TIMES \
|
||||
INSERT_ASM_100_TIMES \
|
||||
INSERT_ASM_100_TIMES \
|
||||
INSERT_ASM_100_TIMES \
|
||||
INSERT_ASM_100_TIMES \
|
||||
INSERT_ASM_100_TIMES \
|
||||
INSERT_ASM_100_TIMES \
|
||||
INSERT_ASM_100_TIMES \
|
||||
|
||||
void nop_function(uint64_t iters) {
|
||||
for (uint64_t i = 0; i < iters; i++) {
|
||||
INSERT_ASM_1000_TIMES
|
||||
INSERT_ASM_1000_TIMES
|
||||
INSERT_ASM_1000_TIMES
|
||||
INSERT_ASM_1000_TIMES
|
||||
}
|
||||
}
|
||||
|
||||
// Run the nop_function with the number of iterations specified and
|
||||
// measure both the time and number of cycles
|
||||
int measure_freq_iters(uint64_t iters, uint32_t core, double* freq) {
|
||||
clockid_t clock = CLOCK_PROCESS_CPUTIME_ID;
|
||||
struct timespec start, end;
|
||||
struct perf_event_attr pe;
|
||||
uint64_t cycles;
|
||||
int fd;
|
||||
int pid = 0;
|
||||
memset(&pe, 0, sizeof(struct perf_event_attr));
|
||||
pe.type = PERF_TYPE_HARDWARE;
|
||||
pe.size = sizeof(struct perf_event_attr);
|
||||
pe.config = PERF_COUNT_HW_CPU_CYCLES;
|
||||
pe.disabled = 1;
|
||||
pe.exclude_kernel = 1;
|
||||
pe.exclude_hv = 1;
|
||||
|
||||
fd = perf_event_open(&pe, pid, core, -1, 0);
|
||||
if (fd == -1) {
|
||||
perror("perf_event_open");
|
||||
if (errno == EPERM || errno == EACCES) {
|
||||
printErr("You may not have permission to collect stats.\n"\
|
||||
"Consider tweaking /proc/sys/kernel/perf_event_paranoid or running as root");
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (clock_gettime(clock, &start) == -1) {
|
||||
perror("clock_gettime");
|
||||
return -1;
|
||||
}
|
||||
if(ioctl(fd, PERF_EVENT_IOC_RESET, 0) == -1) {
|
||||
perror("ioctl");
|
||||
return -1;
|
||||
}
|
||||
if(ioctl(fd, PERF_EVENT_IOC_ENABLE, 0) == -1) {
|
||||
perror("ioctl");
|
||||
return -1;
|
||||
}
|
||||
|
||||
nop_function(iters);
|
||||
|
||||
ssize_t ret = read(fd, &cycles, sizeof(uint64_t));
|
||||
if (ret == -1) {
|
||||
perror("read");
|
||||
return -1;
|
||||
}
|
||||
if (ret != sizeof(uint64_t)) {
|
||||
printErr("Read returned %d, expected %d", ret, sizeof(uint64_t));
|
||||
return -1;
|
||||
}
|
||||
if(ioctl(fd, PERF_EVENT_IOC_DISABLE, 0) == -1) {
|
||||
perror("ioctl");
|
||||
return -1;
|
||||
}
|
||||
if (clock_gettime(clock, &end) == -1) {
|
||||
perror("clock_gettime");
|
||||
return -1;
|
||||
}
|
||||
|
||||
uint64_t nsecs = (end.tv_sec*1e9 + end.tv_nsec) - (start.tv_sec*1e9 + start.tv_nsec);
|
||||
uint64_t usecs = nsecs/1000;
|
||||
*freq = cycles/((double)usecs);
|
||||
return 0;
|
||||
}
|
||||
|
||||
// Return a good number of iterations to run the nop_function in
|
||||
// order to get a precise measurement of the frequency without taking
|
||||
// too much time.
|
||||
uint64_t get_num_iters_from_freq(double frequency) {
|
||||
// Truncate to reduce variability
|
||||
uint64_t freq_trunc = ((uint64_t) frequency / 100) * 100;
|
||||
uint64_t osp_per_iter = 4 * 1000;
|
||||
|
||||
return freq_trunc * 1e7 * 1/osp_per_iter;
|
||||
}
|
||||
|
||||
// Differences between x86 measure_frequency and this measure_max_frequency:
|
||||
// - measure_frequency employs all cores simultaneously whereas
|
||||
// measure_max_frequency only employs 1.
|
||||
// - measure_frequency runs the computation and checks /proc/cpuinfo whereas
|
||||
// measure_max_frequency does not rely on /proc/cpuinfo and simply
|
||||
// counts cpu cycles to measure frequency.
|
||||
// - measure_frequency uses actual computation while measuring the frequency
|
||||
// whereas measure_max_frequency uses nop instructions. This makes the former
|
||||
// x86 dependant whereas the latter is architecture independant.
|
||||
int64_t measure_max_frequency(uint32_t core) {
|
||||
if (!bind_to_cpu(core)) {
|
||||
printErr("Failed binding the process to CPU %d", core);
|
||||
return UNKNOWN_DATA;
|
||||
}
|
||||
|
||||
// First, get very rough estimation of clock cycle to
|
||||
// compute a reasonable value for the iterations
|
||||
double estimation_freq, frequency;
|
||||
uint64_t iters = 100000;
|
||||
if (measure_freq_iters(iters, core, &estimation_freq) == -1)
|
||||
return UNKNOWN_DATA;
|
||||
|
||||
if (estimation_freq <= 0.0) {
|
||||
printErr("First frequency measurement yielded an invalid value: %f", estimation_freq);
|
||||
return UNKNOWN_DATA;
|
||||
}
|
||||
iters = get_num_iters_from_freq(estimation_freq);
|
||||
printWarn("Running frequency measurement with %ld iterations on core %d...", iters, core);
|
||||
|
||||
// Now perform actual measurement
|
||||
const char* frequency_banner = "cpufetch is measuring the max frequency...";
|
||||
printf("%s", frequency_banner);
|
||||
fflush(stdout);
|
||||
|
||||
if (measure_freq_iters(iters, core, &frequency) == -1)
|
||||
return UNKNOWN_DATA;
|
||||
|
||||
// Clean screen once measurement is finished
|
||||
printf("\r%*c\r", (int) strlen(frequency_banner), ' ');
|
||||
|
||||
// Discard last digit in the frequency, which should help providing
|
||||
// more reliable and predictable values.
|
||||
return (((int) frequency + 5)/10) * 10;
|
||||
}
|
||||
|
||||
#endif // #ifdef __linux__
|
||||
@@ -1,6 +0,0 @@
|
||||
#ifndef __COMMON_FREQ__
|
||||
#define __COMMON_FREQ__
|
||||
|
||||
int64_t measure_max_frequency(uint32_t core);
|
||||
|
||||
#endif
|
||||
@@ -1,20 +1,5 @@
|
||||
#ifdef _WIN32
|
||||
#define NOMINMAX
|
||||
#include <windows.h>
|
||||
#elif defined __linux__
|
||||
#define _GNU_SOURCE
|
||||
#include <sched.h>
|
||||
#elif defined __FreeBSD__
|
||||
#include <sys/param.h>
|
||||
#include <sys/cpuset.h>
|
||||
#endif
|
||||
|
||||
#include <stdarg.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <errno.h>
|
||||
|
||||
#include "global.h"
|
||||
|
||||
#ifdef _WIN32
|
||||
@@ -31,40 +16,6 @@
|
||||
|
||||
#endif
|
||||
|
||||
#ifdef ARCH_X86
|
||||
static const char* ARCH_STR = "x86 / x86_64 build";
|
||||
#include "../x86/cpuid.h"
|
||||
#elif ARCH_PPC
|
||||
static const char* ARCH_STR = "PowerPC build";
|
||||
#include "../ppc/ppc.h"
|
||||
#elif ARCH_ARM
|
||||
static const char* ARCH_STR = "ARM build";
|
||||
#include "../arm/midr.h"
|
||||
#elif ARCH_RISCV
|
||||
static const char* ARCH_STR = "RISC-V build";
|
||||
#include "../riscv/riscv.h"
|
||||
#endif
|
||||
|
||||
#ifdef __linux__
|
||||
#ifdef __ANDROID__
|
||||
static const char* OS_STR = "Android";
|
||||
#else
|
||||
static const char* OS_STR = "Linux";
|
||||
#endif
|
||||
#elif __FreeBSD__
|
||||
static const char* OS_STR = "FreeBSD";
|
||||
#elif _WIN32
|
||||
static const char* OS_STR = "Windows";
|
||||
#elif defined __APPLE__ || __MACH__
|
||||
static const char* OS_STR = "macOS";
|
||||
#else
|
||||
static const char* OS_STR = "Unknown OS";
|
||||
#endif
|
||||
|
||||
#ifndef GIT_FULL_VERSION
|
||||
static const char* VERSION = "1.06";
|
||||
#endif
|
||||
|
||||
enum {
|
||||
LOG_LEVEL_NORMAL,
|
||||
LOG_LEVEL_VERBOSE
|
||||
@@ -72,14 +23,6 @@ enum {
|
||||
|
||||
int LOG_LEVEL;
|
||||
|
||||
void printBugMessage(FILE *restrict stream) {
|
||||
#if defined(ARCH_X86) || defined(ARCH_PPC)
|
||||
fprintf(stream, "Please, create a new issue with this error message, the output of 'cpufetch' and 'cpufetch --debug' on https://github.com/Dr-Noob/cpufetch/issues\n");
|
||||
#elif ARCH_ARM
|
||||
fprintf(stream, "Please, create a new issue with this error message, your smartphone/computer model, the output of 'cpufetch --verbose' and 'cpufetch --debug' on https://github.com/Dr-Noob/cpufetch/issues\n");
|
||||
#endif
|
||||
}
|
||||
|
||||
void printWarn(const char *fmt, ...) {
|
||||
if(LOG_LEVEL == LOG_LEVEL_VERBOSE) {
|
||||
int buffer_size = 4096;
|
||||
@@ -100,8 +43,6 @@ void printErr(const char *fmt, ...) {
|
||||
vsnprintf(buffer,buffer_size, fmt, args);
|
||||
va_end(args);
|
||||
fprintf(stderr,RED "[ERROR]: "RESET "%s\n",buffer);
|
||||
fprintf(stderr,"[VERSION]: ");
|
||||
print_version(stderr);
|
||||
}
|
||||
|
||||
void printBug(const char *fmt, ...) {
|
||||
@@ -112,42 +53,10 @@ void printBug(const char *fmt, ...) {
|
||||
vsnprintf(buffer,buffer_size, fmt, args);
|
||||
va_end(args);
|
||||
fprintf(stderr,RED "[ERROR]: "RESET "%s\n",buffer);
|
||||
fprintf(stderr,"[VERSION]: ");
|
||||
print_version(stderr);
|
||||
printBugMessage(stderr);
|
||||
}
|
||||
|
||||
bool isReleaseVersion(char *git_full_version) {
|
||||
return strstr(git_full_version, "-") == NULL;
|
||||
}
|
||||
|
||||
/// The unknown uarch errors are by far the most common error a user will encounter.
|
||||
/// Rather than using the generic printBug function, which asks the user to report
|
||||
/// the problem on the issues webpage, this function will check if the program is
|
||||
/// the release version. In such case, support for this feature is most likely already
|
||||
/// in the last version, so just tell the user to compile that one and not report this
|
||||
/// in github.
|
||||
void printBugCheckRelease(const char *fmt, ...) {
|
||||
int buffer_size = 4096;
|
||||
char buffer[buffer_size];
|
||||
va_list args;
|
||||
va_start(args, fmt);
|
||||
vsnprintf(buffer,buffer_size, fmt, args);
|
||||
va_end(args);
|
||||
|
||||
fprintf(stderr, RED "[ERROR]: "RESET "%s\n", buffer);
|
||||
fprintf(stderr, "[VERSION]: ");
|
||||
print_version(stderr);
|
||||
|
||||
#ifdef GIT_FULL_VERSION
|
||||
if (isReleaseVersion(GIT_FULL_VERSION)) {
|
||||
fprintf(stderr, RED "[ERROR]: "RESET "You are using an outdated version of cpufetch. Please compile cpufetch from source (see https://github.com/Dr-Noob/cpufetch?tab=readme-ov-file#22-building-from-source)");
|
||||
}
|
||||
else {
|
||||
printBugMessage(stderr);
|
||||
}
|
||||
#else
|
||||
printBugMessage(stderr);
|
||||
#ifdef ARCH_X86
|
||||
fprintf(stderr,"Please, create a new issue with this error message and the output of 'cpufetch --debug' in https://github.com/Dr-Noob/cpufetch/issues\n");
|
||||
#elif ARCH_ARM
|
||||
fprintf(stderr,"Please, create a new issue with this error message, your smartphone/computer model and the output of 'cpufetch --debug' in https://github.com/Dr-Noob/cpufetch/issues\n");
|
||||
#endif
|
||||
}
|
||||
|
||||
@@ -155,93 +64,3 @@ void set_log_level(bool verbose) {
|
||||
if(verbose) LOG_LEVEL = LOG_LEVEL_VERBOSE;
|
||||
else LOG_LEVEL = LOG_LEVEL_NORMAL;
|
||||
}
|
||||
|
||||
int max(int a, int b) {
|
||||
return a > b ? a : b;
|
||||
}
|
||||
|
||||
int min(int a, int b) {
|
||||
return a < b ? a : b;
|
||||
}
|
||||
|
||||
char *strremove(char *str, const char *sub) {
|
||||
char *p, *q, *r;
|
||||
if (*sub && (q = r = strstr(str, sub)) != NULL) {
|
||||
size_t len = strlen(sub);
|
||||
while ((r = strstr(p = r + len, sub)) != NULL) {
|
||||
memmove(q, p, r - p);
|
||||
q += r - p;
|
||||
}
|
||||
memmove(q, p, strlen(p) + 1);
|
||||
}
|
||||
return str;
|
||||
}
|
||||
|
||||
void* emalloc(size_t size) {
|
||||
void* ptr = malloc(size);
|
||||
|
||||
if(ptr == NULL) {
|
||||
printErr("malloc failed: %s", strerror(errno));
|
||||
exit(1);
|
||||
}
|
||||
|
||||
return ptr;
|
||||
}
|
||||
|
||||
void* ecalloc(size_t nmemb, size_t size) {
|
||||
void* ptr = calloc(nmemb, size);
|
||||
|
||||
if(ptr == NULL) {
|
||||
printErr("calloc failed: %s", strerror(errno));
|
||||
exit(1);
|
||||
}
|
||||
|
||||
return ptr;
|
||||
}
|
||||
|
||||
void* erealloc(void *ptr, size_t size) {
|
||||
void* newptr = realloc(ptr, size);
|
||||
|
||||
if(newptr == NULL) {
|
||||
printErr("realloc failed: %s", strerror(errno));
|
||||
exit(1);
|
||||
}
|
||||
|
||||
return newptr;
|
||||
}
|
||||
|
||||
#ifndef __APPLE__
|
||||
bool bind_to_cpu(int cpu_id) {
|
||||
#ifdef _WIN32
|
||||
HANDLE process = GetCurrentProcess();
|
||||
DWORD_PTR processAffinityMask = 1 << cpu_id;
|
||||
return SetProcessAffinityMask(process, processAffinityMask);
|
||||
#elif defined __linux__
|
||||
cpu_set_t currentCPU;
|
||||
CPU_ZERO(¤tCPU);
|
||||
CPU_SET(cpu_id, ¤tCPU);
|
||||
if (sched_setaffinity (0, sizeof(currentCPU), ¤tCPU) == -1) {
|
||||
printWarn("sched_setaffinity: %s", strerror(errno));
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
#elif defined __FreeBSD__
|
||||
cpuset_t currentCPU;
|
||||
CPU_ZERO(¤tCPU);
|
||||
CPU_SET(cpu_id, ¤tCPU);
|
||||
if(cpuset_setaffinity(CPU_LEVEL_WHICH, CPU_WHICH_TID, -1, sizeof(cpuset_t), ¤tCPU) == -1) {
|
||||
printWarn("cpuset_setaffinity: %s", strerror(errno));
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
#endif
|
||||
}
|
||||
#endif
|
||||
|
||||
void print_version(FILE *restrict stream) {
|
||||
#ifdef GIT_FULL_VERSION
|
||||
fprintf(stream, "cpufetch %s (%s %s)\n", GIT_FULL_VERSION, OS_STR, ARCH_STR);
|
||||
#else
|
||||
fprintf(stream, "cpufetch v%s (%s %s)\n", VERSION, OS_STR, ARCH_STR);
|
||||
#endif
|
||||
}
|
||||
|
||||
@@ -1,27 +1,11 @@
|
||||
#ifndef __GLOBAL__
|
||||
#define __GLOBAL__
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdbool.h>
|
||||
#include <stddef.h>
|
||||
|
||||
#define STRING_UNKNOWN "Unknown"
|
||||
#define UNUSED(x) (void)(x)
|
||||
|
||||
void set_log_level(bool verbose);
|
||||
void printWarn(const char *fmt, ...);
|
||||
void printErr(const char *fmt, ...);
|
||||
void printBug(const char *fmt, ...);
|
||||
void printBugCheckRelease(const char *fmt, ...);
|
||||
int min(int a, int b);
|
||||
int max(int a, int b);
|
||||
char *strremove(char *str, const char *sub);
|
||||
void* emalloc(size_t size);
|
||||
void* ecalloc(size_t nmemb, size_t size);
|
||||
void* erealloc(void *ptr, size_t size);
|
||||
#ifndef __APPLE__
|
||||
bool bind_to_cpu(int cpu_id);
|
||||
#endif
|
||||
void print_version(FILE *restrict stream);
|
||||
|
||||
#endif
|
||||
|
||||
@@ -1,96 +1,57 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "args.h"
|
||||
#include "printer.h"
|
||||
#include "global.h"
|
||||
|
||||
void print_help(char *argv[]) {
|
||||
const char **t = args_str;
|
||||
const char *c = args_chr;
|
||||
int max_len = max_arg_str_length();
|
||||
|
||||
printf("Usage: %s [OPTION]...\n", argv[0]);
|
||||
printf("Simple yet fancy CPU architecture fetching tool\n\n");
|
||||
|
||||
printf("OPTIONS: \n");
|
||||
printf(" -%c, --%s %*s Set the color scheme (by default, cpufetch uses the system color scheme)\n", c[ARG_COLOR], t[ARG_COLOR], (int) (max_len-strlen(t[ARG_COLOR])), "");
|
||||
printf(" -%c, --%s %*s Set the style of CPU logo\n", c[ARG_STYLE], t[ARG_STYLE], (int) (max_len-strlen(t[ARG_STYLE])), "");
|
||||
#ifdef ARCH_X86
|
||||
printf(" -%c, --%s %*s Print CPU model and cpuid levels (debug purposes)\n", c[ARG_DEBUG], t[ARG_DEBUG], (int) (max_len-strlen(t[ARG_DEBUG])), "");
|
||||
#elif ARCH_PPC
|
||||
printf(" -%c, --%s %*s Print PVR register (debug purposes)\n", c[ARG_DEBUG], t[ARG_DEBUG], (int) (max_len-strlen(t[ARG_DEBUG])), "");
|
||||
static const char* ARCH_STR = "x86_64 build";
|
||||
#include "../x86/cpuid.h"
|
||||
#elif ARCH_ARM
|
||||
printf(" -%c, --%s %*s Print main ID register values (debug purposes)\n", c[ARG_DEBUG], t[ARG_DEBUG], (int) (max_len-strlen(t[ARG_DEBUG])), "");
|
||||
static const char* ARCH_STR = "ARM build";
|
||||
#include "../arm/midr.h"
|
||||
#endif
|
||||
printf(" --%s %*s Show the short version of the logo\n", t[ARG_LOGO_SHORT], (int) (max_len-strlen(t[ARG_LOGO_SHORT])), "");
|
||||
printf(" --%s %*s Show the long version of the logo\n", t[ARG_LOGO_LONG], (int) (max_len-strlen(t[ARG_LOGO_LONG])), "");
|
||||
printf(" -%c, --%s %*s Print extra information (if available) about how cpufetch tried fetching information\n", c[ARG_VERBOSE], t[ARG_VERBOSE], (int) (max_len-strlen(t[ARG_VERBOSE])), "");
|
||||
|
||||
static const char* VERSION = "0.95";
|
||||
|
||||
void print_help(char *argv[]) {
|
||||
printf("Usage: %s [--version] [--help] [--debug] [--style \"fancy\"|\"retro\"|\"legacy\"] [--color \"intel\"|\"amd\"|'R,G,B:R,G,B:R,G,B:R,G,B']\n\n", argv[0]);
|
||||
|
||||
printf("Options: \n\
|
||||
--color Set the color scheme. By default, cpufetch uses the system color scheme. This option \n\
|
||||
lets the user use different colors to print the CPU art: \n\
|
||||
* \"intel\": Use Intel default color scheme \n\
|
||||
* \"amd\": Use AMD default color scheme \n\
|
||||
* \"arm\": Use ARM default color scheme \n\
|
||||
* custom: If color argument do not match \"Intel\", \"AMD\" or \"ARM\", a custom scheme can be specified: \n\
|
||||
4 colors must be given in RGB with the format: R,G,B:R,G,B:... \n\
|
||||
These colors correspond to CPU art color (2 colors) and for the text colors (following 2) \n\
|
||||
For example: --color 239,90,45:210,200,200:100,200,45:0,200,200 \n\n\
|
||||
--style Set the style of CPU art: \n\
|
||||
* \"fancy\": Default style \n\
|
||||
* \"retro\": Old cpufetch style \n\
|
||||
* \"legacy\": Fallback style for terminals that does not support colors \n\n");
|
||||
|
||||
#ifdef ARCH_X86
|
||||
#ifdef __linux__
|
||||
printf(" --%s %*s Compute the peak performance accurately (measure the CPU frequency instead of using the maximum)\n", t[ARG_ACCURATE_PP], (int) (max_len-strlen(t[ARG_ACCURATE_PP])), "");
|
||||
printf(" --%s %*s Measure the max CPU frequency instead of reading it\n", t[ARG_MEASURE_MAX_FREQ], (int) (max_len-strlen(t[ARG_MEASURE_MAX_FREQ])), "");
|
||||
#endif // __linux__
|
||||
printf(" --%s %*s Show the old Intel logo\n", t[ARG_LOGO_INTEL_OLD], (int) (max_len-strlen(t[ARG_LOGO_INTEL_OLD])), "");
|
||||
printf(" --%s %*s Show the new Intel logo\n", t[ARG_LOGO_INTEL_NEW], (int) (max_len-strlen(t[ARG_LOGO_INTEL_NEW])), "");
|
||||
printf(" -%c, --%s %*s Show the full CPU name (do not abbreviate it)\n", c[ARG_FULLCPUNAME], t[ARG_FULLCPUNAME], (int) (max_len-strlen(t[ARG_FULLCPUNAME])), "");
|
||||
printf(" -%c, --%s %*s Print raw cpuid data (debug purposes)\n", c[ARG_RAW], t[ARG_RAW], (int) (max_len-strlen(t[ARG_RAW])), "");
|
||||
#endif // ARCH_X86
|
||||
#ifdef ARCH_ARM
|
||||
#ifdef __linux__
|
||||
printf(" --%s %*s Measure the max CPU frequency instead of reading it\n", t[ARG_MEASURE_MAX_FREQ], (int) (max_len-strlen(t[ARG_MEASURE_MAX_FREQ])), "");
|
||||
printf(" --debug Prints CPU model and cpuid levels (debug purposes)\n\n");
|
||||
#elif ARCH_ARM
|
||||
printf(" --debug Prints main ID register values for all cores (debug purposes)\n\n");
|
||||
#endif
|
||||
#endif
|
||||
printf(" -%c, --%s %*s Print this help and exit\n", c[ARG_HELP], t[ARG_HELP], (int) (max_len-strlen(t[ARG_HELP])), "");
|
||||
printf(" -%c, --%s %*s Print cpufetch version and exit\n", c[ARG_VERSION], t[ARG_VERSION], (int) (max_len-strlen(t[ARG_VERSION])), "");
|
||||
|
||||
printf("\nCOLORS: \n");
|
||||
printf(" * \"intel\": Use Intel color scheme \n");
|
||||
printf(" * \"intel-new\": Use Intel (new logo) color scheme \n");
|
||||
printf(" * \"amd\": Use AMD color scheme \n");
|
||||
printf(" * \"ibm\", Use IBM color scheme \n");
|
||||
printf(" * \"arm\": Use ARM color scheme \n");
|
||||
printf(" * \"rockchip\": Use Rockchip color scheme \n");
|
||||
printf(" * \"sifive\": Use SiFive color scheme \n");
|
||||
printf(" * custom: If the argument of --color does not match any of the previous strings, a custom scheme can be specified.\n");
|
||||
printf(" 5 colors must be given in RGB with the format: R,G,B:R,G,B:...\n");
|
||||
printf(" The first 3 colors are the CPU art color and the next 2 colors are the text colors\n");
|
||||
printf(" --verbose Prints extra information (if available) about how cpufetch tried fetching information\n\n\
|
||||
--help Prints this help and exit\n\n\
|
||||
--version Prints cpufetch version and exit\n\n\
|
||||
\n\
|
||||
NOTES: \n\
|
||||
- Bugs or improvements should be submitted to: github.com/Dr-Noob/cpufetch/issues \n\
|
||||
- Peak performance information is NOT accurate. cpufetch computes peak performance using the max \n\
|
||||
frequency. However, to properly compute peak performance, you need to know the frequency of the \n\
|
||||
CPU running AVX code, which is not be fetched by cpufetch since it depends on each specific CPU. \n");
|
||||
}
|
||||
|
||||
printf("\nSTYLES: \n");
|
||||
printf(" * \"fancy\": Default style\n");
|
||||
printf(" * \"retro\": Old cpufetch style\n");
|
||||
printf(" * \"legacy\": Fallback style for terminals that do not support colors\n");
|
||||
|
||||
printf("\nLOGOS: \n");
|
||||
printf(" cpufetch will try to adapt the logo size and the text to the terminal width. When the output (logo and text) is wider than\n");
|
||||
printf(" the terminal width, cpufetch will print a smaller version of the logo (if it exists). This behavior can be overridden by\n");
|
||||
printf(" --logo-short and --logo-long, which always sets the logo size as specified by the user, even if it is too big. After the\n");
|
||||
printf(" logo selection (either automatically or set by the user), cpufetch will check again if the output fits in the terminal.\n");
|
||||
printf(" If not, it will use a shorter name for the fields (the left part of the text). If, after all of this, the output still does\n");
|
||||
printf(" not fit, cpufetch will cut the text and will only print the text until there is no space left in each line\n");
|
||||
|
||||
printf("\nEXAMPLES: \n");
|
||||
printf(" Run cpufetch with Intel color scheme:\n");
|
||||
printf(" ./cpufetch --color intel\n");
|
||||
printf(" Run cpufetch with a custom color scheme:\n");
|
||||
printf(" ./cpufetch --color 239,90,45:210,200,200:0,0,0:100,200,45:0,200,200\n");
|
||||
|
||||
printf("\nBUGS: \n");
|
||||
printf(" Report bugs to https://github.com/Dr-Noob/cpufetch/issues\n");
|
||||
|
||||
printf("\nNOTE: \n");
|
||||
printf(" Peak performance information is NOT accurate. cpufetch computes peak performance using the max\n");
|
||||
printf(" frequency of the CPU. However, to compute the peak performance, you need to know the frequency of the\n");
|
||||
printf(" CPU running AVX code. By default, this value is not fetched by cpufetch, but you can use the\n");
|
||||
printf(" --accurate-pp option, which will measure the AVX frequency and show a more precise estimation\n");
|
||||
printf(" (this option is only available in x86 architectures).\n");
|
||||
printf(" To precisely measure peak performance, see: https://github.com/Dr-Noob/peakperf\n");
|
||||
printf("\n");
|
||||
printf(" Both --accurate-pp and --measure-max-freq measure the actual frequency of the CPU. However,\n");
|
||||
printf(" they differ slightly. The former measures the max frequency while running vectorized SSE/AVX\n");
|
||||
printf(" instructions and it is thus x86 only, whereas the latter simply measures the max clock cycle\n");
|
||||
printf(" and is architecture independent.\n");
|
||||
void print_version() {
|
||||
printf("cpufetch v%s (%s) [outfile branch]\n",VERSION, ARCH_STR);
|
||||
}
|
||||
|
||||
int main(int argc, char* argv[]) {
|
||||
@@ -98,12 +59,13 @@ int main(int argc, char* argv[]) {
|
||||
return EXIT_FAILURE;
|
||||
|
||||
if(show_help()) {
|
||||
print_version();
|
||||
print_help(argv);
|
||||
return EXIT_SUCCESS;
|
||||
}
|
||||
|
||||
if(show_version()) {
|
||||
print_version(stdout);
|
||||
print_version();
|
||||
return EXIT_SUCCESS;
|
||||
}
|
||||
|
||||
@@ -114,27 +76,13 @@ int main(int argc, char* argv[]) {
|
||||
return EXIT_FAILURE;
|
||||
|
||||
if(show_debug()) {
|
||||
print_version(stdout);
|
||||
print_version();
|
||||
print_debug(cpu);
|
||||
return EXIT_SUCCESS;
|
||||
}
|
||||
|
||||
// TODO: This should be moved to the end of args.c
|
||||
if(show_raw()) {
|
||||
#ifdef ARCH_X86
|
||||
print_version(stdout);
|
||||
print_raw(cpu);
|
||||
if(print_cpufetch(cpu, get_style(), get_colors()))
|
||||
return EXIT_SUCCESS;
|
||||
#else
|
||||
printErr("raw option is valid only in x86_64");
|
||||
return EXIT_FAILURE;
|
||||
#endif
|
||||
}
|
||||
|
||||
if(print_cpufetch(cpu, get_style(), get_colors(), show_full_cpu_name())) {
|
||||
return EXIT_SUCCESS;
|
||||
}
|
||||
else {
|
||||
else
|
||||
return EXIT_FAILURE;
|
||||
}
|
||||
}
|
||||
|
||||
133
src/common/pci.c
133
src/common/pci.c
@@ -1,133 +0,0 @@
|
||||
#define _GNU_SOURCE
|
||||
|
||||
#include <sys/stat.h>
|
||||
#include <dirent.h>
|
||||
|
||||
#include "udev.h"
|
||||
#include "global.h"
|
||||
#include "pci.h"
|
||||
|
||||
#ifndef PATH_MAX
|
||||
#define PATH_MAX 1024
|
||||
#endif
|
||||
|
||||
#define PCI_PATH "/sys/bus/pci/devices/"
|
||||
#define MAX_LENGTH_PCI_DIR_NAME 1024
|
||||
|
||||
// Return a list of PCI devices containing only
|
||||
// the sysfs path
|
||||
struct pci_devices * get_pci_paths(void) {
|
||||
DIR *dirp;
|
||||
|
||||
if ((dirp = opendir(PCI_PATH)) == NULL) {
|
||||
perror("opendir");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
struct dirent *dp;
|
||||
int numDirs = 0;
|
||||
errno = 0;
|
||||
|
||||
while ((dp = readdir(dirp)) != NULL) {
|
||||
if (strcmp(dp->d_name, ".") != 0 && strcmp(dp->d_name, "..") != 0)
|
||||
numDirs++;
|
||||
}
|
||||
if (errno != 0) {
|
||||
perror("readdir");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
rewinddir(dirp);
|
||||
|
||||
struct pci_devices * pci = emalloc(sizeof(struct pci_devices));
|
||||
pci->num_devices = numDirs;
|
||||
pci->devices = emalloc(sizeof(struct pci_device) * pci->num_devices);
|
||||
char * full_path = emalloc(PATH_MAX * sizeof(char));
|
||||
struct stat stbuf;
|
||||
int i = 0;
|
||||
|
||||
while ((dp = readdir(dirp)) != NULL) {
|
||||
if (strcmp(dp->d_name, ".") == 0 || strcmp(dp->d_name, "..") == 0)
|
||||
continue;
|
||||
|
||||
if (strlen(dp->d_name) > MAX_LENGTH_PCI_DIR_NAME) {
|
||||
printErr("Directory name is too long: %s", dp->d_name);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
memset(full_path, 0, PATH_MAX * sizeof(char));
|
||||
snprintf(full_path, min(strlen(PCI_PATH) + strlen(dp->d_name) + 1, PATH_MAX), "%s%s", PCI_PATH, dp->d_name);
|
||||
|
||||
if (stat(full_path, &stbuf) == -1) {
|
||||
perror("stat");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if ((stbuf.st_mode & S_IFMT) == S_IFDIR) {
|
||||
int strLen = min(MAX_LENGTH_PCI_DIR_NAME, strlen(dp->d_name)) + 1;
|
||||
pci->devices[i] = emalloc(sizeof(struct pci_device));
|
||||
pci->devices[i]->path = ecalloc(strLen, sizeof(char));
|
||||
strncpy(pci->devices[i]->path, dp->d_name, strLen);
|
||||
i++;
|
||||
}
|
||||
}
|
||||
if (errno != 0) {
|
||||
perror("readdir");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return pci;
|
||||
}
|
||||
|
||||
// For each PCI device in the list pci, fetch its vendor and
|
||||
// device id using sysfs (e.g., /sys/bus/pci/devices/XXX/{vendor/device})
|
||||
void populate_pci_devices(struct pci_devices * pci) {
|
||||
int filelen;
|
||||
char* buf;
|
||||
|
||||
for (int i=0; i < pci->num_devices; i++) {
|
||||
struct pci_device* dev = pci->devices[i];
|
||||
int path_size = strlen(PCI_PATH) + strlen(dev->path) + 2;
|
||||
|
||||
// Read vendor_id
|
||||
char *vendor_id_path = emalloc(sizeof(char) * (path_size + strlen("vendor") + 1));
|
||||
sprintf(vendor_id_path, "%s/%s/%s", PCI_PATH, dev->path, "vendor");
|
||||
|
||||
if ((buf = read_file(vendor_id_path, &filelen)) == NULL) {
|
||||
printWarn("read_file: %s: %s\n", vendor_id_path, strerror(errno));
|
||||
dev->vendor_id = 0;
|
||||
}
|
||||
else {
|
||||
dev->vendor_id = strtol(buf, NULL, 16);
|
||||
}
|
||||
|
||||
// Read device_id
|
||||
char *device_id_path = emalloc(sizeof(char) * (path_size + strlen("device") + 1));
|
||||
sprintf(device_id_path, "%s/%s/%s", PCI_PATH, dev->path, "device");
|
||||
|
||||
if ((buf = read_file(device_id_path, &filelen)) == NULL) {
|
||||
printWarn("read_file: %s: %s\n", device_id_path, strerror(errno));
|
||||
dev->device_id = 0;
|
||||
}
|
||||
else {
|
||||
dev->device_id = strtol(buf, NULL, 16);
|
||||
}
|
||||
|
||||
free(vendor_id_path);
|
||||
free(device_id_path);
|
||||
}
|
||||
}
|
||||
|
||||
// Return a list of PCI devices that could be used to infer the SoC.
|
||||
// The criteria to determine which devices are suitable for this task
|
||||
// is decided in filter_pci_devices.
|
||||
struct pci_devices * get_pci_devices(void) {
|
||||
struct pci_devices * pci = get_pci_paths();
|
||||
|
||||
if (pci == NULL)
|
||||
return NULL;
|
||||
|
||||
populate_pci_devices(pci);
|
||||
|
||||
return pci;
|
||||
}
|
||||
@@ -1,23 +0,0 @@
|
||||
#ifndef __PCI__
|
||||
#define __PCI__
|
||||
|
||||
#define PCI_VENDOR_NVIDIA 0x10de
|
||||
#define PCI_VENDOR_AMPERE 0x1def
|
||||
|
||||
#define PCI_DEVICE_TEGRA_X1 0x0faf
|
||||
#define PCI_DEVICE_ALTRA 0xe100
|
||||
|
||||
struct pci_device {
|
||||
char * path;
|
||||
uint16_t vendor_id;
|
||||
uint16_t device_id;
|
||||
};
|
||||
|
||||
struct pci_devices {
|
||||
struct pci_device ** devices;
|
||||
int num_devices;
|
||||
};
|
||||
|
||||
struct pci_devices * get_pci_devices(void);
|
||||
|
||||
#endif
|
||||
1184
src/common/printer.c
1184
src/common/printer.c
File diff suppressed because it is too large
Load Diff
@@ -7,29 +7,18 @@ typedef int STYLE;
|
||||
|
||||
#ifdef ARCH_X86
|
||||
#include "../x86/cpuid.h"
|
||||
#elif ARCH_PPC
|
||||
#include "../ppc/ppc.h"
|
||||
#elif ARCH_ARM
|
||||
#else
|
||||
#include "../arm/midr.h"
|
||||
#elif ARCH_RISCV
|
||||
#include "../riscv/riscv.h"
|
||||
#endif
|
||||
|
||||
// +-----------------------------------+-----------------------+
|
||||
// | Color logo | Color text |
|
||||
// | Color 1 | Color 2 | Color 3 | Color 1 | Color 2 |
|
||||
#define COLOR_DEFAULT_INTEL "015,125,194:230,230,230:000,000,000:040,150,220:230,230,230"
|
||||
#define COLOR_DEFAULT_INTEL_NEW "030,204,251:250,250,250:000,104,181:230,230,230:030,204,251"
|
||||
#define COLOR_DEFAULT_AMD "250,250,250:000,154,102:000,000,000:250,250,250:000,154,102"
|
||||
#define COLOR_DEFAULT_IBM "092,119,172:092,119,172:000,000,000:240,240,240:092,119,172"
|
||||
#define COLOR_DEFAULT_ARM "000,145,189:000,145,189:000,000,000:240,240,240:000,145,189"
|
||||
#define COLOR_DEFAULT_ROCKCHIP "114,159,207:229,195,000:000,000,000:240,240,240:114,159,207"
|
||||
#define COLOR_DEFAULT_SIFIVE "255,255,255:000,000,000:000,000,000:255,255,255:000,000,000"
|
||||
#define COLOR_DEFAULT_INTEL "15,125,194:230,230,230:40,150,220:230,230,230"
|
||||
#define COLOR_DEFAULT_AMD "250,250,250:0,154,102:250,250,250:0,154,102"
|
||||
#define COLOR_DEFAULT_ARM "0,145,189:0,145,189:240,240,240:0,145,189"
|
||||
|
||||
#ifdef ARCH_X86
|
||||
void print_levels(struct cpuInfo* cpu);
|
||||
#endif
|
||||
|
||||
bool print_cpufetch(struct cpuInfo* cpu, STYLE s, struct color** cs, bool fcpuname);
|
||||
bool print_cpufetch(struct cpuInfo* cpu, STYLE s, struct colors* cs);
|
||||
|
||||
#endif
|
||||
|
||||
@@ -1,93 +0,0 @@
|
||||
#include "soc.h"
|
||||
#ifdef ARCH_ARM
|
||||
#include "../arm/socs.h"
|
||||
#elif ARCH_RISCV
|
||||
#include "../riscv/socs.h"
|
||||
#endif
|
||||
#include "udev.h"
|
||||
#include "../common/global.h"
|
||||
|
||||
#include <string.h>
|
||||
|
||||
static char* soc_trademark_string[] = {
|
||||
// ARM
|
||||
[SOC_VENDOR_SNAPDRAGON] = "Snapdragon ",
|
||||
[SOC_VENDOR_MEDIATEK] = "MediaTek ",
|
||||
[SOC_VENDOR_EXYNOS] = "Exynos ",
|
||||
[SOC_VENDOR_KIRIN] = "Kirin ",
|
||||
[SOC_VENDOR_KUNPENG] = "Kunpeng ",
|
||||
[SOC_VENDOR_BROADCOM] = "Broadcom ",
|
||||
[SOC_VENDOR_APPLE] = "Apple ",
|
||||
[SOC_VENDOR_ROCKCHIP] = "Rockchip ",
|
||||
[SOC_VENDOR_GOOGLE] = "Google ",
|
||||
[SOC_VENDOR_NVIDIA] = "NVIDIA ",
|
||||
[SOC_VENDOR_AMPERE] = "Ampere ",
|
||||
[SOC_VENDOR_NXP] = "NXP ",
|
||||
[SOC_VENDOR_AMLOGIC] = "Amlogic ",
|
||||
// RISC-V
|
||||
[SOC_VENDOR_SIFIVE] = "SiFive ",
|
||||
[SOC_VENDOR_STARFIVE] = "StarFive ",
|
||||
[SOC_VENDOR_SIPEED] = "Sipeed ",
|
||||
// ARM & RISC-V
|
||||
[SOC_VENDOR_ALLWINNER] = "Allwinner "
|
||||
};
|
||||
|
||||
VENDOR get_soc_vendor(struct system_on_chip* soc) {
|
||||
return soc->vendor;
|
||||
}
|
||||
|
||||
char* get_str_process(struct system_on_chip* soc) {
|
||||
char* str;
|
||||
|
||||
if(soc->process == UNKNOWN) {
|
||||
str = emalloc(sizeof(char) * (strlen(STRING_UNKNOWN)+1));
|
||||
snprintf(str, strlen(STRING_UNKNOWN)+1, STRING_UNKNOWN);
|
||||
}
|
||||
else {
|
||||
int max_process_len = 5 + 1;
|
||||
str = ecalloc(max_process_len, sizeof(char));
|
||||
snprintf(str, max_process_len, "%dnm", soc->process);
|
||||
}
|
||||
return str;
|
||||
}
|
||||
|
||||
char* get_soc_name(struct system_on_chip* soc) {
|
||||
if(soc->model == SOC_MODEL_UNKNOWN)
|
||||
return soc->raw_name;
|
||||
return soc->name;
|
||||
}
|
||||
|
||||
void fill_soc(struct system_on_chip* soc, char* soc_name, SOC soc_model, int32_t process) {
|
||||
soc->model = soc_model;
|
||||
soc->vendor = get_soc_vendor_from_soc(soc_model);
|
||||
soc->process = process;
|
||||
if(soc->vendor == SOC_VENDOR_UNKNOWN) {
|
||||
printBug("fill_soc: soc->vendor == SOC_VENDOR_UNKOWN");
|
||||
// If we fall here there is a bug in socs.h
|
||||
// Reset everything to avoid segfault
|
||||
soc->vendor = SOC_VENDOR_UNKNOWN;
|
||||
soc->model = SOC_MODEL_UNKNOWN;
|
||||
soc->process = UNKNOWN;
|
||||
soc->raw_name = emalloc(sizeof(char) * (strlen(STRING_UNKNOWN)+1));
|
||||
snprintf(soc->raw_name, strlen(STRING_UNKNOWN)+1, STRING_UNKNOWN);
|
||||
}
|
||||
else {
|
||||
int len = strlen(soc_name) + strlen(soc_trademark_string[soc->vendor]) + 1;
|
||||
soc->name = emalloc(sizeof(char) * len);
|
||||
sprintf(soc->name, "%s%s", soc_trademark_string[soc->vendor], soc_name);
|
||||
}
|
||||
}
|
||||
|
||||
bool match_soc(struct system_on_chip* soc, char* raw_name, char* expected_name, char* soc_name, SOC soc_model, int32_t process) {
|
||||
int len1 = strlen(raw_name);
|
||||
int len2 = strlen(expected_name);
|
||||
int len = min(len1, len2);
|
||||
|
||||
if(strncmp(raw_name, expected_name, len) != 0) {
|
||||
return false;
|
||||
}
|
||||
else {
|
||||
fill_soc(soc, soc_name, soc_model, process);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
@@ -1,59 +0,0 @@
|
||||
#ifndef __SOC__
|
||||
#define __SOC__
|
||||
|
||||
// NOTE:
|
||||
// soc.c/soc.h are used by
|
||||
// ARM and RISC-V backends
|
||||
|
||||
#include "../common/cpu.h"
|
||||
#include <stdint.h>
|
||||
|
||||
#define UNKNOWN -1
|
||||
|
||||
typedef int32_t SOC;
|
||||
|
||||
enum {
|
||||
SOC_VENDOR_UNKNOWN,
|
||||
// ARM
|
||||
SOC_VENDOR_SNAPDRAGON,
|
||||
SOC_VENDOR_MEDIATEK,
|
||||
SOC_VENDOR_EXYNOS,
|
||||
SOC_VENDOR_KIRIN,
|
||||
SOC_VENDOR_KUNPENG,
|
||||
SOC_VENDOR_BROADCOM,
|
||||
SOC_VENDOR_APPLE,
|
||||
SOC_VENDOR_ROCKCHIP,
|
||||
SOC_VENDOR_GOOGLE,
|
||||
SOC_VENDOR_NVIDIA,
|
||||
SOC_VENDOR_AMPERE,
|
||||
SOC_VENDOR_NXP,
|
||||
SOC_VENDOR_AMLOGIC,
|
||||
// RISC-V
|
||||
SOC_VENDOR_SIFIVE,
|
||||
SOC_VENDOR_STARFIVE,
|
||||
SOC_VENDOR_SIPEED,
|
||||
// ARM & RISC-V
|
||||
SOC_VENDOR_ALLWINNER
|
||||
};
|
||||
|
||||
struct system_on_chip {
|
||||
SOC model;
|
||||
VENDOR vendor;
|
||||
int32_t process;
|
||||
char* name;
|
||||
char* raw_name;
|
||||
};
|
||||
|
||||
struct system_on_chip* get_soc(struct cpuInfo* cpu);
|
||||
char* get_soc_name(struct system_on_chip* soc);
|
||||
VENDOR get_soc_vendor(struct system_on_chip* soc);
|
||||
bool match_soc(struct system_on_chip* soc, char* raw_name, char* expected_name, char* soc_name, SOC soc_model, int32_t process);
|
||||
char* get_str_process(struct system_on_chip* soc);
|
||||
void fill_soc(struct system_on_chip* soc, char* soc_name, SOC soc_model, int32_t process);
|
||||
|
||||
#define SOC_START if (false) {}
|
||||
#define SOC_EQ(raw_name, expected_name, soc_name, soc_model, soc, process) \
|
||||
else if (match_soc(soc, raw_name, expected_name, soc_name, soc_model, process)) return true;
|
||||
#define SOC_END else { return false; }
|
||||
|
||||
#endif
|
||||
@@ -1,25 +0,0 @@
|
||||
#include <sys/types.h>
|
||||
#include <sys/sysctl.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <errno.h>
|
||||
|
||||
#include "global.h"
|
||||
#include "cpu.h"
|
||||
|
||||
uint32_t get_sys_info_by_name(char* name) {
|
||||
size_t size = 0;
|
||||
uint32_t ret = 0;
|
||||
|
||||
if (sysctlbyname(name, NULL, &size, NULL, 0) != 0) {
|
||||
printWarn("sysctlbyname(%s) failed: %s", name, strerror(errno));
|
||||
}
|
||||
else if (size == sizeof(uint32_t)) {
|
||||
sysctlbyname(name, &ret, &size, NULL, 0);
|
||||
}
|
||||
else {
|
||||
printWarn("sysctl does not support non-integer lookup for '%s'", name);
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
@@ -1,56 +0,0 @@
|
||||
#ifndef __SYSCTL__
|
||||
#define __SYSCTL__
|
||||
|
||||
// From Linux kernel: arch/arm64/include/asm/cputype.h
|
||||
#define MIDR_APPLE_M1_ICESTORM 0x610F0220
|
||||
#define MIDR_APPLE_M1_FIRESTORM 0x610F0230
|
||||
// Kernel does not include those, so I just assume that
|
||||
// APPLE_CPU_PART_M2_BLIZZARD=0x30,M2_AVALANCHE=0x31
|
||||
#define MIDR_APPLE_M2_BLIZZARD 0x610F0300
|
||||
#define MIDR_APPLE_M2_AVALANCHE 0x610F0310
|
||||
// https://github.com/AsahiLinux/m1n1/blob/main/src/chickens.c
|
||||
#define MIDR_APPLE_M3_SAWTOOTH 0x610F0480
|
||||
#define MIDR_APPLE_M3_EVEREST 0x610F0490
|
||||
|
||||
// M1 / A14
|
||||
#ifndef CPUFAMILY_ARM_FIRESTORM_ICESTORM
|
||||
#define CPUFAMILY_ARM_FIRESTORM_ICESTORM 0x1B588BB3
|
||||
#endif
|
||||
// M2 / A15
|
||||
#ifndef CPUFAMILY_ARM_AVALANCHE_BLIZZARD
|
||||
#define CPUFAMILY_ARM_AVALANCHE_BLIZZARD 0xDA33D83D
|
||||
#endif
|
||||
// M3 / A16 / A17
|
||||
// M3: https://ratfactor.com/zig/stdlib-browseable2/c/darwin.zig.html
|
||||
// M3_2: https://github.com/Dr-Noob/cpufetch/issues/230
|
||||
// PRO: https://github.com/Dr-Noob/cpufetch/issues/225
|
||||
// MAX: https://github.com/Dr-Noob/cpufetch/issues/210
|
||||
#define CPUFAMILY_ARM_EVEREST_SAWTOOTH 0x8765EDEA
|
||||
#define CPUFAMILY_ARM_EVEREST_SAWTOOTH_2 0xFA33415E
|
||||
#define CPUFAMILY_ARM_EVEREST_SAWTOOTH_PRO 0x5F4DEA93
|
||||
#define CPUFAMILY_ARM_EVEREST_SAWTOOTH_MAX 0x72015832
|
||||
|
||||
// For detecting different M1 types
|
||||
// NOTE: Could also be achieved detecting different
|
||||
// MIDR values (e.g., APPLE_CPU_PART_M1_ICESTORM_PRO)
|
||||
#ifndef CPUSUBFAMILY_ARM_HG
|
||||
#define CPUSUBFAMILY_ARM_HG 2
|
||||
#endif
|
||||
#ifndef CPUSUBFAMILY_ARM_HS
|
||||
#define CPUSUBFAMILY_ARM_HS 4
|
||||
#endif
|
||||
#ifndef CPUSUBFAMILY_ARM_HC_HD
|
||||
#define CPUSUBFAMILY_ARM_HC_HD 5
|
||||
#endif
|
||||
|
||||
// For alternative way to get CPU frequency on macOS and *BSD
|
||||
#ifdef __APPLE__
|
||||
#define CPUFREQUENCY_SYSCTL "hw.cpufrequency_max"
|
||||
#else
|
||||
// For FreeBSD, not sure about other *BSD
|
||||
#define CPUFREQUENCY_SYSCTL "dev.cpu.0.freq"
|
||||
#endif
|
||||
|
||||
uint32_t get_sys_info_by_name(char* name);
|
||||
|
||||
#endif
|
||||
@@ -1,52 +1,7 @@
|
||||
#include "../common/global.h"
|
||||
#include "udev.h"
|
||||
#include "global.h"
|
||||
#include "cpu.h"
|
||||
|
||||
#define _PATH_DEVTREE "/proc/device-tree/compatible"
|
||||
|
||||
// https://www.kernel.org/doc/html/latest/core-api/cpu_hotplug.html
|
||||
int get_ncores_from_cpuinfo(void) {
|
||||
// Examples:
|
||||
// 0-271
|
||||
// 0-7
|
||||
// 0
|
||||
|
||||
int filelen;
|
||||
char* buf;
|
||||
if((buf = read_file(_PATH_CPUS_PRESENT, &filelen)) == NULL) {
|
||||
printWarn("read_file: %s: %s\n", _PATH_CPUS_PRESENT, strerror(errno));
|
||||
return -1;
|
||||
}
|
||||
|
||||
int ncores;
|
||||
char* tmp1;
|
||||
if((tmp1 = strstr(buf, "-")) == NULL) {
|
||||
// file contains no - character, we assume that it contains 0,
|
||||
// which means that the CPU contains only one core
|
||||
return 1;
|
||||
}
|
||||
else {
|
||||
tmp1++;
|
||||
}
|
||||
char* tmp2 = strstr(buf, "\n");
|
||||
char ncores_str[filelen];
|
||||
memset(ncores_str, 0, sizeof(char) * filelen);
|
||||
memcpy(ncores_str, tmp1, tmp2-tmp1);
|
||||
|
||||
char* end;
|
||||
errno = 0;
|
||||
ncores = strtol(ncores_str, &end, 10) + 1;
|
||||
if(errno != 0) {
|
||||
printWarn("strtol: %s:\n", strerror(errno));
|
||||
return -1;
|
||||
}
|
||||
|
||||
free(buf);
|
||||
|
||||
return ncores;
|
||||
}
|
||||
|
||||
char* read_file(char* path, int* len) {
|
||||
int fd = open(path, O_RDONLY);
|
||||
|
||||
@@ -57,18 +12,13 @@ char* read_file(char* path, int* len) {
|
||||
//File exists, read it
|
||||
int bytes_read = 0;
|
||||
int offset = 0;
|
||||
int block = 1024;
|
||||
int buf_size = block * 4;
|
||||
char* buf = emalloc(sizeof(char) * buf_size);
|
||||
int block = 128;
|
||||
char* buf = malloc(sizeof(char)*DEFAULT_FILE_SIZE);
|
||||
memset(buf, 0, sizeof(char)*DEFAULT_FILE_SIZE);
|
||||
|
||||
while ( (bytes_read = read(fd, buf+offset, block)) > 0 ) {
|
||||
offset += bytes_read;
|
||||
if(offset + block > buf_size) {
|
||||
buf = erealloc(buf, sizeof(char) * (buf_size + block));
|
||||
buf_size += block;
|
||||
}
|
||||
}
|
||||
buf[offset] = '\0';
|
||||
|
||||
if (close(fd) == -1) {
|
||||
return NULL;
|
||||
@@ -78,21 +28,32 @@ char* read_file(char* path, int* len) {
|
||||
return buf;
|
||||
}
|
||||
|
||||
long get_freq_from_file(char* path) {
|
||||
long get_freq_from_file(char* path, bool hv_present) {
|
||||
int filelen;
|
||||
char* buf;
|
||||
if((buf = read_file(path, &filelen)) == NULL) {
|
||||
#ifdef ARCH_X86
|
||||
if(hv_present) {
|
||||
printWarn("Could not open '%s'", path);
|
||||
return UNKNOWN_DATA;
|
||||
}
|
||||
else {
|
||||
perror("open");
|
||||
printBug("Could not open '%s'", path);
|
||||
}
|
||||
#elif ARCH_ARM
|
||||
printWarn("Could not open '%s'", path);
|
||||
#endif
|
||||
return UNKNOWN_FREQ;
|
||||
}
|
||||
|
||||
char* end;
|
||||
errno = 0;
|
||||
long ret = strtol(buf, &end, 10);
|
||||
if(errno != 0) {
|
||||
printBug("strtol: %s", strerror(errno));
|
||||
perror("strtol");
|
||||
printBug("Failed parsing '%s' file. Read data was: '%s'", path, buf);
|
||||
free(buf);
|
||||
return UNKNOWN_DATA;
|
||||
return UNKNOWN_FREQ;
|
||||
}
|
||||
|
||||
// We will be getting the frequency in KHz
|
||||
@@ -100,7 +61,7 @@ long get_freq_from_file(char* path) {
|
||||
// greater than 10 GHz or less than 100 MHz
|
||||
if(ret > 10000 * 1000 || ret < 100 * 1000) {
|
||||
printBug("Invalid data was read from file '%s': %ld\n", path, ret);
|
||||
return UNKNOWN_DATA;
|
||||
return UNKNOWN_FREQ;
|
||||
}
|
||||
|
||||
free(buf);
|
||||
@@ -108,256 +69,14 @@ long get_freq_from_file(char* path) {
|
||||
return ret/1000;
|
||||
}
|
||||
|
||||
long get_cache_size_from_file(char* path) {
|
||||
int filelen;
|
||||
char* buf;
|
||||
if((buf = read_file(path, &filelen)) == NULL) {
|
||||
printWarn("Could not open '%s'", path);
|
||||
return -1;
|
||||
}
|
||||
|
||||
buf[filelen] = '\0'; // remove the K at the end
|
||||
|
||||
char* end;
|
||||
errno = 0;
|
||||
long ret = strtol(buf, &end, 10);
|
||||
if(errno != 0) {
|
||||
printBug("strtol: %s", strerror(errno));
|
||||
free(buf);
|
||||
return -1;
|
||||
}
|
||||
|
||||
free(buf);
|
||||
|
||||
return ret * 1024;
|
||||
}
|
||||
|
||||
char* get_field_from_cpuinfo(char* CPUINFO_FIELD) {
|
||||
int filelen;
|
||||
char* buf;
|
||||
if((buf = read_file(_PATH_CPUINFO, &filelen)) == NULL) {
|
||||
printWarn("read_file: %s: %s:\n", _PATH_CPUINFO, strerror(errno));
|
||||
return NULL;
|
||||
}
|
||||
|
||||
char* tmp1 = strstr(buf, CPUINFO_FIELD);
|
||||
if(tmp1 == NULL) return NULL;
|
||||
tmp1 = tmp1 + strlen(CPUINFO_FIELD);
|
||||
char* tmp2 = strstr(tmp1, "\n");
|
||||
|
||||
int strlen = (1 + (tmp2-tmp1));
|
||||
char* hardware = ecalloc(strlen, sizeof(char));
|
||||
strncpy(hardware, tmp1, tmp2-tmp1);
|
||||
|
||||
return hardware;
|
||||
}
|
||||
|
||||
long get_max_freq_from_file(uint32_t core) {
|
||||
long get_max_freq_from_file(uint32_t core, bool hv_present) {
|
||||
char path[_PATH_FREQUENCY_MAX_LEN];
|
||||
sprintf(path, "%s%s/cpu%d%s%s", _PATH_SYS_SYSTEM, _PATH_SYS_CPU, core, _PATH_FREQUENCY, _PATH_FREQUENCY_MAX);
|
||||
return get_freq_from_file(path);
|
||||
return get_freq_from_file(path, hv_present);
|
||||
}
|
||||
|
||||
long get_min_freq_from_file(uint32_t core) {
|
||||
long get_min_freq_from_file(uint32_t core, bool hv_present) {
|
||||
char path[_PATH_FREQUENCY_MAX_LEN];
|
||||
sprintf(path, "%s%s/cpu%d%s%s", _PATH_SYS_SYSTEM, _PATH_SYS_CPU, core, _PATH_FREQUENCY, _PATH_FREQUENCY_MIN);
|
||||
return get_freq_from_file(path);
|
||||
}
|
||||
|
||||
long get_l1i_cache_size(uint32_t core) {
|
||||
char path[_PATH_CACHE_MAX_LEN];
|
||||
sprintf(path, "%s%s/cpu%d%s%s", _PATH_SYS_SYSTEM, _PATH_SYS_CPU, core, _PATH_CACHE_L1I, _PATH_CACHE_SIZE);
|
||||
return get_cache_size_from_file(path);
|
||||
}
|
||||
|
||||
long get_l1d_cache_size(uint32_t core) {
|
||||
char path[_PATH_CACHE_MAX_LEN];
|
||||
sprintf(path, "%s%s/cpu%d%s%s", _PATH_SYS_SYSTEM, _PATH_SYS_CPU, core, _PATH_CACHE_L1D, _PATH_CACHE_SIZE);
|
||||
return get_cache_size_from_file(path);
|
||||
}
|
||||
|
||||
long get_l2_cache_size(uint32_t core) {
|
||||
char path[_PATH_CACHE_MAX_LEN];
|
||||
sprintf(path, "%s%s/cpu%d%s%s", _PATH_SYS_SYSTEM, _PATH_SYS_CPU, core, _PATH_CACHE_L2, _PATH_CACHE_SIZE);
|
||||
return get_cache_size_from_file(path);
|
||||
}
|
||||
|
||||
long get_l3_cache_size(uint32_t core) {
|
||||
char path[_PATH_CACHE_MAX_LEN];
|
||||
sprintf(path, "%s%s/cpu%d%s%s", _PATH_SYS_SYSTEM, _PATH_SYS_CPU, core, _PATH_CACHE_L3, _PATH_CACHE_SIZE);
|
||||
return get_cache_size_from_file(path);
|
||||
}
|
||||
|
||||
void add_shared_map(uint32_t** src, int src_idx, uint32_t** dst, int dst_idx, int n) {
|
||||
for(int j=0; j < n; j++) {
|
||||
dst[dst_idx][j] = src[src_idx][j];
|
||||
}
|
||||
}
|
||||
|
||||
bool maps_equal(uint32_t* map1, uint32_t* map2, int n) {
|
||||
for(int i=0; i < n; i++) {
|
||||
if(map1[i] != map2[i]) return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
// Generic function to count the number of distinct
|
||||
// elements in the list of files passed in char** paths.
|
||||
// An element can be potentially anything.
|
||||
// We use this function to count:
|
||||
// - The number of caches
|
||||
// - The number of sockets
|
||||
int get_num_elements_from_files(char** paths, int num_paths) {
|
||||
int filelen;
|
||||
char* buf;
|
||||
char* tmpbuf;
|
||||
|
||||
// 1. Count the number of bitmasks per file
|
||||
if((buf = read_file(paths[0], &filelen)) == NULL) {
|
||||
printWarn("Could not open '%s'", paths[0]);
|
||||
return -1;
|
||||
}
|
||||
int num_bitmasks = 1;
|
||||
for(int i=0; buf[i]; i++) {
|
||||
num_bitmasks += (buf[i] == ',');
|
||||
}
|
||||
|
||||
// 2. Read map from every core
|
||||
uint32_t** maps = emalloc(sizeof(uint32_t *) * num_paths);
|
||||
for(int i=0; i < num_paths; i++) {
|
||||
maps[i] = emalloc(sizeof(uint32_t) * num_bitmasks);
|
||||
|
||||
if((buf = read_file(paths[i], &filelen)) == NULL) {
|
||||
printWarn("Could not open '%s'", paths[i]);
|
||||
return -1;
|
||||
}
|
||||
|
||||
for(int j=0; j < num_bitmasks; j++) {
|
||||
char* end;
|
||||
tmpbuf = emalloc(sizeof(char) * (strlen(buf) + 1));
|
||||
memset(tmpbuf, 0, sizeof(char) * (strlen(buf) + 1));
|
||||
char* commaend = strstr(buf, ",");
|
||||
if(commaend == NULL) {
|
||||
strcpy(tmpbuf, buf);
|
||||
}
|
||||
else {
|
||||
strncpy(tmpbuf, buf, commaend-buf);
|
||||
}
|
||||
errno = 0;
|
||||
long ret = strtol(tmpbuf, &end, 16);
|
||||
if(errno != 0) {
|
||||
printf("strtol: %s", strerror(errno));
|
||||
free(buf);
|
||||
return -1;
|
||||
}
|
||||
|
||||
maps[i][j] = (uint32_t) ret;
|
||||
buf = commaend + 1;
|
||||
free(tmpbuf);
|
||||
}
|
||||
}
|
||||
|
||||
// 2. Count number of different masks; this is the number of elements
|
||||
int num_elements = 0;
|
||||
bool found = false;
|
||||
uint32_t** unique_maps = emalloc(sizeof(uint32_t *) * num_paths);
|
||||
for(int i=0; i < num_paths; i++) {
|
||||
unique_maps[i] = emalloc(sizeof(uint32_t) * num_bitmasks);
|
||||
for(int j=0; j < num_bitmasks; j++) {
|
||||
unique_maps[i][j] = 0;
|
||||
}
|
||||
}
|
||||
|
||||
for(int i=0; i < num_paths; i++) {
|
||||
for(int j=0; j < num_paths && !found; j++) {
|
||||
if(maps_equal(maps[i], unique_maps[j], num_bitmasks)) found = true;
|
||||
}
|
||||
if(!found) {
|
||||
add_shared_map(maps, i, unique_maps, num_elements, num_bitmasks);
|
||||
num_elements++;
|
||||
}
|
||||
found = false;
|
||||
}
|
||||
|
||||
return num_elements;
|
||||
}
|
||||
|
||||
int get_num_caches_from_files(char** paths, int num_paths) {
|
||||
return get_num_elements_from_files(paths, num_paths);
|
||||
}
|
||||
|
||||
int get_num_sockets_from_files(char** paths, int num_paths) {
|
||||
return get_num_elements_from_files(paths, num_paths);
|
||||
}
|
||||
|
||||
int get_num_caches_by_level(struct cpuInfo* cpu, uint32_t level) {
|
||||
char** paths = emalloc(sizeof(char *) * cpu->topo->total_cores);
|
||||
char* cache_path = NULL;
|
||||
|
||||
if(level == 0) cache_path = _PATH_CACHE_L1I;
|
||||
else if(level == 1) cache_path = _PATH_CACHE_L1D;
|
||||
else if(level == 2) cache_path = _PATH_CACHE_L2;
|
||||
else if(level == 3) cache_path = _PATH_CACHE_L3;
|
||||
else {
|
||||
printBug("Found invalid cache level to inspect: %d\n", level);
|
||||
return -1;
|
||||
}
|
||||
|
||||
for(int i=0; i < cpu->topo->total_cores; i++) {
|
||||
paths[i] = emalloc(sizeof(char) * _PATH_CACHE_MAX_LEN);
|
||||
sprintf(paths[i], "%s%s/cpu%d%s%s", _PATH_SYS_SYSTEM, _PATH_SYS_CPU, i, cache_path, _PATH_CACHE_SHARED_MAP);
|
||||
}
|
||||
|
||||
int ret = get_num_caches_from_files(paths, cpu->topo->total_cores);
|
||||
|
||||
for(int i=0; i < cpu->topo->total_cores; i++)
|
||||
free(paths[i]);
|
||||
free(paths);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
int get_num_sockets_package_cpus(struct topology* topo) {
|
||||
// Get number of sockets using
|
||||
// /sys/devices/system/cpu/cpu*/topology/package_cpus
|
||||
|
||||
char** paths = emalloc(sizeof(char *) * topo->total_cores);
|
||||
|
||||
for(int i=0; i < topo->total_cores; i++) {
|
||||
paths[i] = emalloc(sizeof(char) * _PATH_PACKAGE_MAX_LEN);
|
||||
sprintf(paths[i], "%s%s/cpu%d%s", _PATH_SYS_SYSTEM, _PATH_SYS_CPU, i, _PATH_TOPO_PACKAGE_CPUS);
|
||||
}
|
||||
|
||||
int ret = get_num_sockets_from_files(paths, topo->total_cores);
|
||||
|
||||
for(int i=0; i < topo->total_cores; i++)
|
||||
free(paths[i]);
|
||||
free(paths);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
// Inspired in is_devtree_compatible from lscpu
|
||||
bool is_devtree_compatible(char* str) {
|
||||
int filelen;
|
||||
char* buf;
|
||||
if((buf = read_file("/proc/device-tree/compatible", &filelen)) == NULL) {
|
||||
return false;
|
||||
}
|
||||
|
||||
char* tmp;
|
||||
if((tmp = strstr(buf, str)) == NULL) {
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
char* get_devtree_compatible(int *filelen) {
|
||||
char* buf;
|
||||
|
||||
if ((buf = read_file(_PATH_DEVTREE, filelen)) == NULL) {
|
||||
printWarn("read_file: %s: %s", _PATH_DEVTREE, strerror(errno));
|
||||
}
|
||||
|
||||
return buf;
|
||||
return get_freq_from_file(path, hv_present);
|
||||
}
|
||||
|
||||
@@ -12,37 +12,17 @@
|
||||
|
||||
#include "cpu.h"
|
||||
|
||||
#define _PATH_CPUINFO "/proc/cpuinfo"
|
||||
#define _PATH_SYS_SYSTEM "/sys/devices/system"
|
||||
#define _PATH_SYS_CPU "/cpu"
|
||||
#define _PATH_FREQUENCY "/cpufreq"
|
||||
#define _PATH_FREQUENCY_MAX "/cpuinfo_max_freq"
|
||||
#define _PATH_FREQUENCY_MIN "/cpuinfo_min_freq"
|
||||
#define _PATH_CACHE_L1D "/cache/index0"
|
||||
#define _PATH_CACHE_L1I "/cache/index1"
|
||||
#define _PATH_CACHE_L2 "/cache/index2"
|
||||
#define _PATH_CACHE_L3 "/cache/index3"
|
||||
#define _PATH_CACHE_SIZE "/size"
|
||||
#define _PATH_CACHE_SHARED_MAP "/shared_cpu_map"
|
||||
#define _PATH_CPUS_PRESENT _PATH_SYS_SYSTEM _PATH_SYS_CPU "/present"
|
||||
#define _PATH_TOPO_PACKAGE_CPUS "/topology/package_cpus"
|
||||
|
||||
#define _PATH_FREQUENCY_MAX_LEN 100
|
||||
#define _PATH_CACHE_MAX_LEN 200
|
||||
#define _PATH_PACKAGE_MAX_LEN 200
|
||||
#define DEFAULT_FILE_SIZE 4096
|
||||
|
||||
char* read_file(char* path, int* len);
|
||||
long get_max_freq_from_file(uint32_t core);
|
||||
long get_min_freq_from_file(uint32_t core);
|
||||
long get_l1i_cache_size(uint32_t core);
|
||||
long get_l1d_cache_size(uint32_t core);
|
||||
long get_l2_cache_size(uint32_t core);
|
||||
long get_l3_cache_size(uint32_t core);
|
||||
int get_num_caches_by_level(struct cpuInfo* cpu, uint32_t level);
|
||||
int get_num_sockets_package_cpus(struct topology* topo);
|
||||
int get_ncores_from_cpuinfo(void);
|
||||
char* get_field_from_cpuinfo(char* CPUINFO_FIELD);
|
||||
bool is_devtree_compatible(char* str);
|
||||
char* get_devtree_compatible(int *filelen);
|
||||
long get_max_freq_from_file(uint32_t core, bool hv_present);
|
||||
long get_min_freq_from_file(uint32_t core, bool hv_present);
|
||||
|
||||
#endif
|
||||
|
||||
276
src/ppc/ppc.c
276
src/ppc/ppc.c
@@ -1,276 +0,0 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <unistd.h>
|
||||
#include <assert.h>
|
||||
|
||||
#include "ppc.h"
|
||||
#include "uarch.h"
|
||||
#include "udev.h"
|
||||
#include "../common/udev.h"
|
||||
#include "../common/global.h"
|
||||
|
||||
static char *hv_vendors_name[] = {
|
||||
[HV_VENDOR_KVM] = "KVM",
|
||||
[HV_VENDOR_QEMU] = "QEMU",
|
||||
[HV_VENDOR_VBOX] = "VirtualBox",
|
||||
[HV_VENDOR_HYPERV] = "Microsoft Hyper-V",
|
||||
[HV_VENDOR_VMWARE] = "VMware",
|
||||
[HV_VENDOR_XEN] = "Xen",
|
||||
[HV_VENDOR_PARALLELS] = "Parallels",
|
||||
[HV_VENDOR_PHYP] = "pHyp",
|
||||
[HV_VENDOR_BHYVE] = "bhyve",
|
||||
[HV_VENDOR_APPLEVZ] = "Apple VZ",
|
||||
[HV_VENDOR_INVALID] = STRING_UNKNOWN
|
||||
};
|
||||
|
||||
struct cache* get_cache_info(struct cpuInfo* cpu) {
|
||||
struct cache* cach = emalloc(sizeof(struct cache));
|
||||
init_cache_struct(cach);
|
||||
|
||||
cach->L1i->size = get_l1i_cache_size(0);
|
||||
cach->L1d->size = get_l1d_cache_size(0);
|
||||
cach->L2->size = get_l2_cache_size(0);
|
||||
cach->L3->size = get_l3_cache_size(0);
|
||||
|
||||
if(cach->L1i->size > 0) {
|
||||
cach->L1i->exists = true;
|
||||
cach->L1i->num_caches = get_num_caches_by_level(cpu, 0);
|
||||
cach->max_cache_level = 1;
|
||||
}
|
||||
if(cach->L1d->size > 0) {
|
||||
cach->L1d->exists = true;
|
||||
cach->L1d->num_caches = get_num_caches_by_level(cpu, 1);
|
||||
cach->max_cache_level = 2;
|
||||
}
|
||||
if(cach->L2->size > 0) {
|
||||
cach->L2->exists = true;
|
||||
cach->L2->num_caches = get_num_caches_by_level(cpu, 2);
|
||||
cach->max_cache_level = 3;
|
||||
}
|
||||
if(cach->L3->size > 0) {
|
||||
cach->L3->exists = true;
|
||||
cach->L3->num_caches = get_num_caches_by_level(cpu, 3);
|
||||
cach->max_cache_level = 4;
|
||||
}
|
||||
|
||||
return cach;
|
||||
}
|
||||
|
||||
struct topology* get_topology_info(struct cache* cach) {
|
||||
struct topology* topo = emalloc(sizeof(struct topology));
|
||||
init_topology_struct(topo, cach);
|
||||
|
||||
// 1. Total cores detection
|
||||
if((topo->total_cores = sysconf(_SC_NPROCESSORS_ONLN)) == -1) {
|
||||
printWarn("sysconf(_SC_NPROCESSORS_ONLN): %s", strerror(errno));
|
||||
topo->total_cores = 1; // fallback
|
||||
}
|
||||
|
||||
// To find physical cores, we use topo->total_cores and core_ids
|
||||
// To find number of sockets, we use package_ids
|
||||
int* core_ids = emalloc(sizeof(int) * topo->total_cores);
|
||||
int* package_ids = emalloc(sizeof(int) * topo->total_cores);
|
||||
|
||||
if(!fill_core_ids_from_sys(core_ids, topo->total_cores)) {
|
||||
printWarn("fill_core_ids_from_sys failed, output may be incomplete/invalid");
|
||||
for(int i=0; i < topo->total_cores; i++) core_ids[i] = 0;
|
||||
}
|
||||
|
||||
if(!fill_package_ids_from_sys(package_ids, topo->total_cores)) {
|
||||
printWarn("fill_package_ids_from_sys failed, output may be incomplete/invalid");
|
||||
for(int i=0; i < topo->total_cores; i++) package_ids[i] = 0;
|
||||
// fill_package_ids_from_sys failed, use udev to try
|
||||
// to find the number of sockets
|
||||
topo->sockets = get_num_sockets_package_cpus(topo);
|
||||
if (topo->sockets == UNKNOWN_DATA) {
|
||||
printWarn("get_num_sockets_package_cpus failed: assuming 1 socket");
|
||||
topo->sockets = 1;
|
||||
}
|
||||
}
|
||||
else {
|
||||
// fill_package_ids_from_sys succeeded, use the
|
||||
// traditional socket detection algorithm
|
||||
int *package_ids_count = emalloc(sizeof(int) * topo->total_cores);
|
||||
for(int i=0; i < topo->total_cores; i++) {
|
||||
package_ids_count[i] = 0;
|
||||
}
|
||||
for(int i=0; i < topo->total_cores; i++) {
|
||||
package_ids_count[package_ids[i]]++;
|
||||
}
|
||||
for(int i=0; i < topo->total_cores; i++) {
|
||||
if(package_ids_count[i] != 0) {
|
||||
topo->sockets++;
|
||||
}
|
||||
}
|
||||
free(package_ids_count);
|
||||
}
|
||||
|
||||
// 3. Physical cores detection
|
||||
int *core_ids_unified = emalloc(sizeof(int) * topo->total_cores);
|
||||
for(int i=0; i < topo->total_cores; i++) {
|
||||
core_ids_unified[i] = -1;
|
||||
}
|
||||
bool found = false;
|
||||
for(int i=0; i < topo->total_cores; i++) {
|
||||
for(int j=0; j < topo->total_cores && !found; j++) {
|
||||
if(core_ids_unified[j] == core_ids[i]) found = true;
|
||||
}
|
||||
if(!found) {
|
||||
core_ids_unified[topo->physical_cores] = core_ids[i];
|
||||
topo->physical_cores++;
|
||||
}
|
||||
found = false;
|
||||
}
|
||||
|
||||
topo->physical_cores = topo->physical_cores / topo->sockets; // only count cores on one socket
|
||||
topo->logical_cores = topo->total_cores / topo->sockets; // only count threads on one socket
|
||||
topo->smt_supported = topo->logical_cores / topo->physical_cores;
|
||||
|
||||
free(core_ids);
|
||||
free(package_ids);
|
||||
free(core_ids_unified);
|
||||
|
||||
return topo;
|
||||
}
|
||||
|
||||
static inline uint32_t mfpvr(void) {
|
||||
uint32_t pvr;
|
||||
|
||||
asm ("mfpvr %0"
|
||||
: "=r"(pvr));
|
||||
return pvr;
|
||||
}
|
||||
|
||||
struct uarch* get_cpu_uarch(struct cpuInfo* cpu) {
|
||||
return get_uarch_from_pvr(cpu->pvr);
|
||||
}
|
||||
|
||||
struct frequency* get_frequency_info(void) {
|
||||
struct frequency* freq = emalloc(sizeof(struct frequency));
|
||||
|
||||
freq->measured = false;
|
||||
freq->max = get_max_freq_from_file(0);
|
||||
freq->base = get_min_freq_from_file(0);
|
||||
|
||||
if(freq->max == UNKNOWN_DATA) {
|
||||
// If we are unable to find it in the
|
||||
// standard path, try /proc/cpuinfo
|
||||
freq->max = get_frequency_from_cpuinfo();
|
||||
}
|
||||
|
||||
return freq;
|
||||
}
|
||||
|
||||
int64_t get_peak_performance(struct cpuInfo* cpu, struct topology* topo, int64_t freq) {
|
||||
/*
|
||||
* Not sure about this
|
||||
* PP(SP) = N_CORES * FREQUENCY * 4(If altivec)
|
||||
*/
|
||||
|
||||
//First check we have consistent data
|
||||
if(freq == UNKNOWN_DATA) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
struct features* feat = cpu->feat;
|
||||
int64_t flops = topo->physical_cores * topo->sockets * (freq * 1000000);
|
||||
if(feat->altivec) flops = flops * 4;
|
||||
|
||||
// POWER9 has the concept called "slices". Each SMT4 core has two super-slices,
|
||||
// and each super-slice is capable of doing two FLOPS per cycle. In the case of
|
||||
// SMT8, it has 4 super-slices, thus four FLOPS per cycle.
|
||||
if(is_power9(cpu->arch)) {
|
||||
int threads_per_core = topo->logical_cores / topo->physical_cores;
|
||||
flops = flops * (threads_per_core / 2);
|
||||
}
|
||||
|
||||
return flops;
|
||||
}
|
||||
|
||||
struct hypervisor* get_hp_info(void) {
|
||||
struct hypervisor* hv = emalloc(sizeof(struct hypervisor));
|
||||
hv->present = false;
|
||||
|
||||
// Weird heuristic found in lscpu:
|
||||
// https://github.com/util-linux/util-linux/blob/master/sys-utils/lscpu-virt.c
|
||||
if(access("/proc" _PATH_DT_IBM_PARTIT_NAME, F_OK) == 0 &&
|
||||
access("/proc" _PATH_DT_HMC_MANAGED, F_OK) == 0 &&
|
||||
access("/proc" _PATH_DT_QEMU_WIDTH, F_OK) != 0) {
|
||||
hv->present = true;
|
||||
hv->hv_vendor = HV_VENDOR_PHYP;
|
||||
}
|
||||
else if(is_devtree_compatible("qemu,pseries")) {
|
||||
hv->present = true;
|
||||
hv->hv_vendor = HV_VENDOR_QEMU;
|
||||
}
|
||||
|
||||
hv->hv_name = hv_vendors_name[hv->hv_vendor];
|
||||
|
||||
return hv;
|
||||
}
|
||||
|
||||
struct cpuInfo* get_cpu_info(void) {
|
||||
struct cpuInfo* cpu = emalloc(sizeof(struct cpuInfo));
|
||||
struct features* feat = emalloc(sizeof(struct features));
|
||||
cpu->feat = feat;
|
||||
|
||||
bool *ptr = &(feat->AES);
|
||||
for(uint32_t i = 0; i < sizeof(struct features)/sizeof(bool); i++, ptr++) {
|
||||
*ptr = false;
|
||||
}
|
||||
|
||||
int len;
|
||||
char* path = emalloc(sizeof(char) * (strlen(_PATH_DT) + strlen(_PATH_DT_PART) + 1));
|
||||
sprintf(path, "%s%s", _PATH_DT, _PATH_DT_PART);
|
||||
|
||||
if((cpu->cpu_name = read_file(path, &len)) == NULL) {
|
||||
printWarn("Could not open '%s'", path);
|
||||
}
|
||||
cpu->pvr = mfpvr();
|
||||
cpu->hv = get_hp_info();
|
||||
cpu->arch = get_cpu_uarch(cpu);
|
||||
cpu->freq = get_frequency_info();
|
||||
cpu->topo = get_topology_info(cpu->cach);
|
||||
cpu->cach = get_cache_info(cpu);
|
||||
feat->altivec = has_altivec(cpu->arch);
|
||||
cpu->peak_performance = get_peak_performance(cpu, cpu->topo, get_freq(cpu->freq));
|
||||
|
||||
return cpu;
|
||||
}
|
||||
|
||||
char* get_str_altivec(struct cpuInfo* cpu) {
|
||||
char* string = ecalloc(4, sizeof(char));
|
||||
|
||||
if(cpu->feat->altivec) strcpy(string, "Yes");
|
||||
else strcpy(string, "No");
|
||||
|
||||
return string;
|
||||
}
|
||||
|
||||
char* get_str_topology(struct topology* topo, bool dual_socket) {
|
||||
char* string;
|
||||
if(topo->smt_supported > 1) {
|
||||
uint32_t size = 3+3+17+1;
|
||||
string = emalloc(sizeof(char)*size);
|
||||
if(dual_socket)
|
||||
snprintf(string, size, "%d cores (%d threads)", topo->physical_cores * topo->sockets, topo->logical_cores * topo->sockets);
|
||||
else
|
||||
snprintf(string, size, "%d cores (%d threads)",topo->physical_cores,topo->logical_cores);
|
||||
}
|
||||
else {
|
||||
uint32_t size = 3+7+1;
|
||||
string = emalloc(sizeof(char)*size);
|
||||
if(dual_socket)
|
||||
snprintf(string, size, "%d cores",topo->physical_cores * topo->sockets);
|
||||
else
|
||||
snprintf(string, size, "%d cores",topo->physical_cores);
|
||||
}
|
||||
return string;
|
||||
}
|
||||
|
||||
|
||||
void print_debug(struct cpuInfo* cpu) {
|
||||
printf("PVR: 0x%.8X\n", cpu->pvr);
|
||||
}
|
||||
@@ -1,11 +0,0 @@
|
||||
#ifndef __CPUFETCH_POWERPC__
|
||||
#define __CPUFETCH_POWERPC__
|
||||
|
||||
#include "../common/cpu.h"
|
||||
|
||||
struct cpuInfo* get_cpu_info(void);
|
||||
char* get_str_altivec(struct cpuInfo* cpu);
|
||||
char* get_str_topology(struct topology* topo, bool dual_socket);
|
||||
void print_debug(struct cpuInfo* cpu);
|
||||
|
||||
#endif
|
||||
@@ -1,28 +0,0 @@
|
||||
#!/bin/bash
|
||||
|
||||
# This script takes as input cputable.c from linux kernel
|
||||
# and generates a valid output for cpufetch in src/ppc/uarch.c
|
||||
|
||||
CPUTABLE_PATH="linux-5.13.7/arch/powerpc/kernel/cputable.c"
|
||||
|
||||
raw_values=$(grep '\.pvr_value' "$CPUTABLE_PATH" | grep -oP "= .*," | cut -d' ' -f2 | tr -d ',')
|
||||
raw_masks=$(grep '\.pvr_mask' "$CPUTABLE_PATH" | grep -oE "0x........")
|
||||
|
||||
raw_v_len=$(echo "$raw_values" | wc -l)
|
||||
raw_m_len=$(echo "$raw_masks" | wc -l)
|
||||
|
||||
if [ $raw_v_len -ne $raw_m_len ]
|
||||
then
|
||||
echo "Lengths do not match!"
|
||||
echo "values length: $raw_v_len"
|
||||
echo "masks length: $raw_m_len"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
IFS=$'\n' read -r -d ' ' -a values <<< "$raw_values"
|
||||
IFS=$'\n' read -r -d ' ' -a masks <<< "$raw_masks"
|
||||
|
||||
for i in "${!values[@]}"
|
||||
do
|
||||
echo ' CHECK_UARCH(arch, pvr, '"${masks[i]}"', '"${values[i]}"', "POWERX", UARCH_POWERX, -1)'
|
||||
done
|
||||
300
src/ppc/uarch.c
300
src/ppc/uarch.c
@@ -1,300 +0,0 @@
|
||||
#include <stdint.h>
|
||||
#include <stdbool.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <errno.h>
|
||||
|
||||
#include "uarch.h"
|
||||
#include "../common/global.h"
|
||||
|
||||
typedef uint32_t MICROARCH;
|
||||
|
||||
// Data not available
|
||||
#define NA -1
|
||||
|
||||
// Unknown manufacturing process
|
||||
#define UNK -1
|
||||
|
||||
enum {
|
||||
UARCH_UNKNOWN,
|
||||
UARCH_PPC604,
|
||||
UARCH_PPCG3,
|
||||
UARCH_PPCG4,
|
||||
UARCH_PPC405,
|
||||
UARCH_PPC603,
|
||||
UARCH_PPC440,
|
||||
UARCH_PPC470,
|
||||
UARCH_ESPRESSO, // Not exactly an uarch, but the codename of Wii U
|
||||
UARCH_PPC970,
|
||||
UARCH_PPC970FX,
|
||||
UARCH_PPC970MP,
|
||||
UARCH_CELLBE,
|
||||
UARCH_POWER5,
|
||||
UARCH_POWER5PLUS,
|
||||
UARCH_POWER6,
|
||||
UARCH_POWER7,
|
||||
UARCH_POWER7PLUS,
|
||||
UARCH_POWER8,
|
||||
UARCH_POWER8_DD21,
|
||||
UARCH_POWER9,
|
||||
UARCH_POWER9_DD20,
|
||||
UARCH_POWER9_DD21,
|
||||
UARCH_POWER9_DD22,
|
||||
UARCH_POWER9_DD23,
|
||||
UARCH_POWER10,
|
||||
};
|
||||
|
||||
struct uarch {
|
||||
MICROARCH uarch;
|
||||
char* uarch_str;
|
||||
int32_t process; // measured in nanometers
|
||||
};
|
||||
|
||||
#define UARCH_START if (false) {}
|
||||
#define CHECK_UARCH(arch, cpu_pvr, pvr_mask, pvr_value, uarch) \
|
||||
else if ((cpu_pvr & pvr_mask) == pvr_value) fill_uarch(arch, uarch);
|
||||
#define UARCH_END else { printBug("Unknown microarchitecture detected: 0x%.8X", pvr); fill_uarch(arch, UARCH_UNKNOWN); }
|
||||
|
||||
#define FILL_START if (false) {}
|
||||
#define FILL_UARCH(u, uarch, uarch_str, uarch_process) \
|
||||
else if(u == uarch) { fill = true; str = uarch_str; process = uarch_process; }
|
||||
#define FILL_END else { printBug("Found invalid microarchitecture: %d", u); }
|
||||
|
||||
void fill_uarch(struct uarch* arch, MICROARCH u) {
|
||||
arch->uarch = u;
|
||||
char* str = NULL;
|
||||
int32_t process = UNK;
|
||||
bool fill = false;
|
||||
|
||||
FILL_START
|
||||
FILL_UARCH(arch->uarch, UARCH_UNKNOWN, STRING_UNKNOWN, UNK)
|
||||
FILL_UARCH(arch->uarch, UARCH_PPC604, "PowerPC 604", 500)
|
||||
FILL_UARCH(arch->uarch, UARCH_PPCG3, "PowerPC G3", UNK) // varies
|
||||
FILL_UARCH(arch->uarch, UARCH_PPCG4, "PowerPC G4", UNK) // varies
|
||||
FILL_UARCH(arch->uarch, UARCH_PPC405, "PowerPC 405", UNK)
|
||||
FILL_UARCH(arch->uarch, UARCH_PPC603, "PowerPC 603", UNK) // varies
|
||||
FILL_UARCH(arch->uarch, UARCH_PPC440, "PowerPC 440", UNK)
|
||||
FILL_UARCH(arch->uarch, UARCH_PPC470, "PowerPC 470", 45) // strange...
|
||||
FILL_UARCH(arch->uarch, UARCH_ESPRESSO, "Espresso", 45) // https://en.wikipedia.org/wiki/PowerPC_7xx#Espresso, https://en.wikipedia.org/wiki/Espresso_(processor), https://github.com/Dr-Noob/cpufetch/issues/231
|
||||
FILL_UARCH(arch->uarch, UARCH_PPC970, "PowerPC 970", 130)
|
||||
FILL_UARCH(arch->uarch, UARCH_PPC970FX, "PowerPC 970FX", 90)
|
||||
FILL_UARCH(arch->uarch, UARCH_PPC970MP, "PowerPC 970MP", 90)
|
||||
FILL_UARCH(arch->uarch, UARCH_CELLBE, "Cell BE", UNK) // varies depending on manufacturer
|
||||
FILL_UARCH(arch->uarch, UARCH_POWER5, "POWER5", 130)
|
||||
FILL_UARCH(arch->uarch, UARCH_POWER5PLUS, "POWER5+", 90)
|
||||
FILL_UARCH(arch->uarch, UARCH_POWER6, "POWER6", 65)
|
||||
FILL_UARCH(arch->uarch, UARCH_POWER7, "POWER7", 45)
|
||||
FILL_UARCH(arch->uarch, UARCH_POWER7PLUS, "POWER7+", 32)
|
||||
FILL_UARCH(arch->uarch, UARCH_POWER8, "POWER8", 22)
|
||||
FILL_UARCH(arch->uarch, UARCH_POWER8_DD21, "POWER8 (DD2.1)", 22)
|
||||
FILL_UARCH(arch->uarch, UARCH_POWER9, "POWER9", 14)
|
||||
FILL_UARCH(arch->uarch, UARCH_POWER9_DD20, "POWER9 (DD2.0)", 14)
|
||||
FILL_UARCH(arch->uarch, UARCH_POWER9_DD21, "POWER9 (DD2.1)", 14)
|
||||
FILL_UARCH(arch->uarch, UARCH_POWER9_DD22, "POWER9 (DD2.2)", 14)
|
||||
FILL_UARCH(arch->uarch, UARCH_POWER9_DD23, "POWER9 (DD2.3)", 14)
|
||||
FILL_UARCH(arch->uarch, UARCH_POWER10, "POWER10", 7)
|
||||
FILL_END
|
||||
|
||||
if(fill) {
|
||||
arch->uarch_str = emalloc(sizeof(char) * (strlen(str)+1));
|
||||
strcpy(arch->uarch_str, str);
|
||||
arch->process= process;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* PVR masks/values from Linux kernel:
|
||||
* - arch/powerpc/kernel/cputable.c (kernel <= 6.0)
|
||||
* - arch/powerpc/kernel/cpu_specs_book3s_64.h (kernel >= 6.1)
|
||||
*
|
||||
* In the kernel, there is a POWER8E identifier. In
|
||||
* https://wiki.raptorcs.com/wiki/POWER8E it says it is
|
||||
* actually DD2.1, while other POWER8 should be DD2.0.
|
||||
* The last assumption does not seem to be correct according
|
||||
* to https://openbenchmarking.org/s/POWER8NVL, which shows a
|
||||
* POWER8NVL where kernel says it is DD1.0. We implement this
|
||||
* to show only the uarch, not the revision, since it seems a bit
|
||||
* redundant?
|
||||
*
|
||||
* This list may be incorrect, incomplete or overly simplified,
|
||||
* specially in the case of 32 bit entries
|
||||
*/
|
||||
struct uarch* get_uarch_from_pvr(uint32_t pvr) {
|
||||
struct uarch* arch = emalloc(sizeof(struct uarch));
|
||||
|
||||
UARCH_START
|
||||
// 64 bit
|
||||
CHECK_UARCH(arch, pvr, 0xffff0000, 0x00390000, UARCH_PPC970)
|
||||
CHECK_UARCH(arch, pvr, 0xffff0000, 0x003c0000, UARCH_PPC970FX)
|
||||
CHECK_UARCH(arch, pvr, 0xffffffff, 0x00440100, UARCH_PPC970MP)
|
||||
CHECK_UARCH(arch, pvr, 0xffff0000, 0x00440000, UARCH_PPC970MP)
|
||||
CHECK_UARCH(arch, pvr, 0xffff0000, 0x003a0000, UARCH_POWER5)
|
||||
CHECK_UARCH(arch, pvr, 0xffffff00, 0x003b0300, UARCH_POWER5PLUS)
|
||||
CHECK_UARCH(arch, pvr, 0xffff0000, 0x003b0000, UARCH_POWER5)
|
||||
CHECK_UARCH(arch, pvr, 0xffffffff, 0x0f000001, UARCH_POWER5)
|
||||
CHECK_UARCH(arch, pvr, 0xffff0000, 0x003e0000, UARCH_POWER6)
|
||||
CHECK_UARCH(arch, pvr, 0xffffffff, 0x0f000002, UARCH_POWER6)
|
||||
CHECK_UARCH(arch, pvr, 0xffffffff, 0x0f000003, UARCH_POWER7)
|
||||
CHECK_UARCH(arch, pvr, 0xffffffff, 0x0f000004, UARCH_POWER8)
|
||||
CHECK_UARCH(arch, pvr, 0xffffffff, 0x0f000005, UARCH_POWER9)
|
||||
CHECK_UARCH(arch, pvr, 0xffffffff, 0x0f000006, UARCH_POWER10)
|
||||
CHECK_UARCH(arch, pvr, 0xffff0000, 0x003f0000, UARCH_POWER7)
|
||||
CHECK_UARCH(arch, pvr, 0xffff0000, 0x004A0000, UARCH_POWER7PLUS)
|
||||
CHECK_UARCH(arch, pvr, 0xffff0000, 0x004b0000, UARCH_POWER8_DD21)
|
||||
CHECK_UARCH(arch, pvr, 0xffff0000, 0x004c0000, UARCH_POWER8)
|
||||
CHECK_UARCH(arch, pvr, 0xffff0000, 0x004d0000, UARCH_POWER8)
|
||||
CHECK_UARCH(arch, pvr, 0xffffefff, 0x004e0200, UARCH_POWER9_DD20)
|
||||
CHECK_UARCH(arch, pvr, 0xffffefff, 0x004e0201, UARCH_POWER9_DD21)
|
||||
CHECK_UARCH(arch, pvr, 0xffffefff, 0x004e0202, UARCH_POWER9_DD22)
|
||||
CHECK_UARCH(arch, pvr, 0xffffefff, 0x004e0203, UARCH_POWER9_DD23)
|
||||
CHECK_UARCH(arch, pvr, 0xffff0000, 0x00800000, UARCH_POWER10)
|
||||
CHECK_UARCH(arch, pvr, 0xffff0000, 0x00700000, UARCH_CELLBE)
|
||||
// 32 bit
|
||||
CHECK_UARCH(arch, pvr, 0xffff0000, 0x00040000, UARCH_PPC604)
|
||||
CHECK_UARCH(arch, pvr, 0xfffff000, 0x00090000, UARCH_PPC604)
|
||||
CHECK_UARCH(arch, pvr, 0xffff0000, 0x00090000, UARCH_PPC604)
|
||||
CHECK_UARCH(arch, pvr, 0xffff0000, 0x000a0000, UARCH_PPC604)
|
||||
CHECK_UARCH(arch, pvr, 0xffffffff, 0x00084202, UARCH_PPCG3)
|
||||
CHECK_UARCH(arch, pvr, 0xfffffff0, 0x00080100, UARCH_PPCG3)
|
||||
CHECK_UARCH(arch, pvr, 0xfffffff0, 0x00082200, UARCH_PPCG3)
|
||||
CHECK_UARCH(arch, pvr, 0xfffffff0, 0x00082210, UARCH_PPCG3)
|
||||
CHECK_UARCH(arch, pvr, 0xffffffff, 0x00083214, UARCH_PPCG3)
|
||||
CHECK_UARCH(arch, pvr, 0xfffff0e0, 0x00087000, UARCH_PPCG3)
|
||||
CHECK_UARCH(arch, pvr, 0xfffff000, 0x00083000, UARCH_PPCG3)
|
||||
CHECK_UARCH(arch, pvr, 0xffffff00, 0x70000100, UARCH_PPCG3)
|
||||
CHECK_UARCH(arch, pvr, 0xffffffff, 0x70000200, UARCH_PPCG3)
|
||||
CHECK_UARCH(arch, pvr, 0xffff0000, 0x70000000, UARCH_PPCG3)
|
||||
CHECK_UARCH(arch, pvr, 0xffff0000, 0x70020000, UARCH_PPCG3)
|
||||
CHECK_UARCH(arch, pvr, 0xffff0000, 0x00080000, UARCH_PPCG3)
|
||||
CHECK_UARCH(arch, pvr, 0xffffffff, 0x000c1101, UARCH_PPCG4)
|
||||
CHECK_UARCH(arch, pvr, 0xffff0000, 0x000c0000, UARCH_PPCG4)
|
||||
CHECK_UARCH(arch, pvr, 0xffff0000, 0x800c0000, UARCH_PPCG4)
|
||||
CHECK_UARCH(arch, pvr, 0xffffffff, 0x80000200, UARCH_PPCG4)
|
||||
CHECK_UARCH(arch, pvr, 0xffffffff, 0x80000201, UARCH_PPCG4)
|
||||
CHECK_UARCH(arch, pvr, 0xffff0000, 0x80000000, UARCH_PPCG4)
|
||||
CHECK_UARCH(arch, pvr, 0xffffff00, 0x80010100, UARCH_PPCG4)
|
||||
CHECK_UARCH(arch, pvr, 0xffffffff, 0x80010200, UARCH_PPCG4)
|
||||
CHECK_UARCH(arch, pvr, 0xffff0000, 0x80010000, UARCH_PPCG4)
|
||||
CHECK_UARCH(arch, pvr, 0xffffffff, 0x80020100, UARCH_PPCG4)
|
||||
CHECK_UARCH(arch, pvr, 0xffffffff, 0x80020101, UARCH_PPCG4)
|
||||
CHECK_UARCH(arch, pvr, 0xffff0000, 0x80020000, UARCH_PPCG4)
|
||||
CHECK_UARCH(arch, pvr, 0xffff0000, 0x80030000, UARCH_PPCG4)
|
||||
CHECK_UARCH(arch, pvr, 0xffff0000, 0x80040000, UARCH_PPCG4)
|
||||
CHECK_UARCH(arch, pvr, 0xffff0000, 0x00030000, UARCH_PPC603)
|
||||
CHECK_UARCH(arch, pvr, 0xffff0000, 0x00060000, UARCH_PPC603)
|
||||
CHECK_UARCH(arch, pvr, 0xffff0000, 0x00070000, UARCH_PPC603)
|
||||
CHECK_UARCH(arch, pvr, 0x7fff0000, 0x00810000, UARCH_PPC603)
|
||||
CHECK_UARCH(arch, pvr, 0x7fff0000, 0x00820000, UARCH_PPC603)
|
||||
CHECK_UARCH(arch, pvr, 0x7fff0000, 0x00830000, UARCH_PPC603)
|
||||
CHECK_UARCH(arch, pvr, 0x7fff0000, 0x00840000, UARCH_PPC603)
|
||||
CHECK_UARCH(arch, pvr, 0x7fff0000, 0x00850000, UARCH_PPC603)
|
||||
CHECK_UARCH(arch, pvr, 0x7fff0000, 0x00860000, UARCH_PPC603)
|
||||
CHECK_UARCH(arch, pvr, 0xffff0000, 0x41810000, UARCH_PPC405)
|
||||
CHECK_UARCH(arch, pvr, 0xffff0000, 0x41610000, UARCH_PPC405)
|
||||
CHECK_UARCH(arch, pvr, 0xffff0000, 0x40B10000, UARCH_PPC405)
|
||||
CHECK_UARCH(arch, pvr, 0xffff0000, 0x41410000, UARCH_PPC405)
|
||||
CHECK_UARCH(arch, pvr, 0xffff0000, 0x50910000, UARCH_PPC405)
|
||||
CHECK_UARCH(arch, pvr, 0xffff0000, 0x51510000, UARCH_PPC405)
|
||||
CHECK_UARCH(arch, pvr, 0xffff0000, 0x41F10000, UARCH_PPC405)
|
||||
CHECK_UARCH(arch, pvr, 0xffff0000, 0x51210000, UARCH_PPC405)
|
||||
CHECK_UARCH(arch, pvr, 0xffff000f, 0x12910007, UARCH_PPC405)
|
||||
CHECK_UARCH(arch, pvr, 0xffff000f, 0x1291000d, UARCH_PPC405)
|
||||
CHECK_UARCH(arch, pvr, 0xffff000f, 0x1291000f, UARCH_PPC405)
|
||||
CHECK_UARCH(arch, pvr, 0xffff000f, 0x12910003, UARCH_PPC405)
|
||||
CHECK_UARCH(arch, pvr, 0xffff000f, 0x12910005, UARCH_PPC405)
|
||||
CHECK_UARCH(arch, pvr, 0xffff000f, 0x12910001, UARCH_PPC405)
|
||||
CHECK_UARCH(arch, pvr, 0xffff000f, 0x12910009, UARCH_PPC405)
|
||||
CHECK_UARCH(arch, pvr, 0xffff000f, 0x1291000b, UARCH_PPC405)
|
||||
CHECK_UARCH(arch, pvr, 0xffff000f, 0x12910000, UARCH_PPC405)
|
||||
CHECK_UARCH(arch, pvr, 0xffff000f, 0x12910002, UARCH_PPC405)
|
||||
CHECK_UARCH(arch, pvr, 0xffff0000, 0x41510000, UARCH_PPC405)
|
||||
CHECK_UARCH(arch, pvr, 0xffff0000, 0x7ff11432, UARCH_PPC405)
|
||||
CHECK_UARCH(arch, pvr, 0xf0000fff, 0x40000850, UARCH_PPC440)
|
||||
CHECK_UARCH(arch, pvr, 0xf0000fff, 0x40000858, UARCH_PPC440)
|
||||
CHECK_UARCH(arch, pvr, 0xf0000fff, 0x400008d3, UARCH_PPC440)
|
||||
CHECK_UARCH(arch, pvr, 0xf0000ff7, 0x400008d4, UARCH_PPC440)
|
||||
CHECK_UARCH(arch, pvr, 0xf0000fff, 0x400008db, UARCH_PPC440)
|
||||
CHECK_UARCH(arch, pvr, 0xf0000ffb, 0x200008D0, UARCH_PPC440)
|
||||
CHECK_UARCH(arch, pvr, 0xf0000ffb, 0x200008D8, UARCH_PPC440)
|
||||
CHECK_UARCH(arch, pvr, 0xf0000fff, 0x40000440, UARCH_PPC440)
|
||||
CHECK_UARCH(arch, pvr, 0xf0000fff, 0x40000481, UARCH_PPC440)
|
||||
CHECK_UARCH(arch, pvr, 0xf0000fff, 0x50000850, UARCH_PPC440)
|
||||
CHECK_UARCH(arch, pvr, 0xf0000fff, 0x50000851, UARCH_PPC440)
|
||||
CHECK_UARCH(arch, pvr, 0xf0000fff, 0x50000892, UARCH_PPC440)
|
||||
CHECK_UARCH(arch, pvr, 0xf0000fff, 0x50000894, UARCH_PPC440)
|
||||
CHECK_UARCH(arch, pvr, 0xfff00fff, 0x53200891, UARCH_PPC440)
|
||||
CHECK_UARCH(arch, pvr, 0xfff00fff, 0x53400890, UARCH_PPC440)
|
||||
CHECK_UARCH(arch, pvr, 0xfff00fff, 0x53400891, UARCH_PPC440)
|
||||
CHECK_UARCH(arch, pvr, 0xffff0006, 0x13020002, UARCH_PPC440)
|
||||
CHECK_UARCH(arch, pvr, 0xffff0007, 0x13020004, UARCH_PPC440)
|
||||
CHECK_UARCH(arch, pvr, 0xffff0006, 0x13020000, UARCH_PPC440)
|
||||
CHECK_UARCH(arch, pvr, 0xffff0007, 0x13020005, UARCH_PPC440)
|
||||
CHECK_UARCH(arch, pvr, 0xffffff00, 0x13541800, UARCH_PPC440)
|
||||
CHECK_UARCH(arch, pvr, 0xfffffff0, 0x12C41C80, UARCH_PPC440)
|
||||
CHECK_UARCH(arch, pvr, 0xffffffff, 0x11a52080, UARCH_PPC470)
|
||||
CHECK_UARCH(arch, pvr, 0xffff0000, 0x7ff50000, UARCH_PPC470)
|
||||
CHECK_UARCH(arch, pvr, 0xffff0000, 0x00050000, UARCH_PPC470)
|
||||
CHECK_UARCH(arch, pvr, 0xffff0000, 0x11a50000, UARCH_PPC470)
|
||||
CHECK_UARCH(arch, pvr, 0xffffffff, 0x70010201, UARCH_ESPRESSO)
|
||||
UARCH_END
|
||||
|
||||
return arch;
|
||||
}
|
||||
|
||||
bool has_altivec(struct uarch* arch) {
|
||||
switch(arch->uarch) {
|
||||
case UARCH_PPC970FX:
|
||||
case UARCH_PPC970MP:
|
||||
case UARCH_CELLBE:
|
||||
case UARCH_POWER6:
|
||||
case UARCH_POWER7:
|
||||
case UARCH_POWER7PLUS:
|
||||
case UARCH_POWER8:
|
||||
case UARCH_POWER8_DD21:
|
||||
case UARCH_POWER9:
|
||||
case UARCH_POWER9_DD20:
|
||||
case UARCH_POWER9_DD21:
|
||||
case UARCH_POWER9_DD22:
|
||||
case UARCH_POWER9_DD23:
|
||||
case UARCH_POWER10:
|
||||
return true;
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
bool is_power9(struct uarch* arch) {
|
||||
return arch->uarch == UARCH_POWER9 ||
|
||||
arch->uarch == UARCH_POWER9_DD20 ||
|
||||
arch->uarch == UARCH_POWER9_DD21 ||
|
||||
arch->uarch == UARCH_POWER9_DD22 ||
|
||||
arch->uarch == UARCH_POWER9_DD23;
|
||||
}
|
||||
|
||||
char* get_str_uarch(struct cpuInfo* cpu) {
|
||||
return cpu->arch->uarch_str;
|
||||
}
|
||||
|
||||
char* get_str_process(struct cpuInfo* cpu) {
|
||||
char* str = emalloc(sizeof(char) * (strlen(STRING_UNKNOWN)+1));
|
||||
int32_t process = cpu->arch->process;
|
||||
|
||||
if(process == UNK) {
|
||||
snprintf(str, strlen(STRING_UNKNOWN)+1, STRING_UNKNOWN);
|
||||
}
|
||||
else if(process > 0){
|
||||
sprintf(str, "%dnm", process);
|
||||
}
|
||||
else {
|
||||
snprintf(str, strlen(STRING_UNKNOWN)+1, STRING_UNKNOWN);
|
||||
printBug("Found invalid process: '%d'", process);
|
||||
}
|
||||
|
||||
return str;
|
||||
}
|
||||
|
||||
void free_uarch_struct(struct uarch* arch) {
|
||||
free(arch->uarch_str);
|
||||
free(arch);
|
||||
}
|
||||
@@ -1,16 +0,0 @@
|
||||
#ifndef __UARCH__
|
||||
#define __UARCH__
|
||||
|
||||
#include <stdint.h>
|
||||
#include "ppc.h"
|
||||
|
||||
struct uarch;
|
||||
|
||||
struct uarch* get_uarch_from_pvr(uint32_t pvr);
|
||||
bool has_altivec(struct uarch* arch);
|
||||
bool is_power9(struct uarch* arch);
|
||||
char* get_str_uarch(struct cpuInfo* cpu);
|
||||
char* get_str_process(struct cpuInfo* cpu);
|
||||
void free_uarch_struct(struct uarch* arch);
|
||||
|
||||
#endif
|
||||
@@ -1,90 +0,0 @@
|
||||
#include <errno.h>
|
||||
|
||||
#include "../common/udev.h"
|
||||
#include "../common/global.h"
|
||||
#include "udev.h"
|
||||
|
||||
#define _PATH_TOPO_CORE_ID "topology/core_id"
|
||||
#define _PATH_TOPO_PACKAGE_ID "topology/physical_package_id"
|
||||
#define CPUINFO_FREQUENCY_STR "clock\t\t: "
|
||||
|
||||
bool fill_array_from_sys(int *core_ids, int total_cores, char* SYS_PATH) {
|
||||
int filelen;
|
||||
char* buf;
|
||||
char* end;
|
||||
char path[128];
|
||||
memset(name, 0, sizeof(char) * 128);
|
||||
|
||||
for(int i=0; i < total_cores; i++) {
|
||||
sprintf(path, "%s%s/cpu%d/%s", _PATH_SYS_SYSTEM, _PATH_SYS_CPU, i, SYS_PATH);
|
||||
if((buf = read_file(path, &filelen)) == NULL) {
|
||||
printWarn("fill_array_from_sys: %s: %s", path, strerror(errno));
|
||||
return false;
|
||||
}
|
||||
|
||||
errno = 0;
|
||||
core_ids[i] = strtol(buf, &end, 10);
|
||||
if(errno != 0) {
|
||||
printWarn("fill_array_from_sys: %s:", strerror(errno));
|
||||
return false;
|
||||
}
|
||||
free(buf);
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool fill_core_ids_from_sys(int *core_ids, int total_cores) {
|
||||
return fill_array_from_sys(core_ids, total_cores, _PATH_TOPO_CORE_ID);
|
||||
}
|
||||
|
||||
bool fill_package_ids_from_sys(int* package_ids, int total_cores) {
|
||||
bool status = fill_array_from_sys(package_ids, total_cores, _PATH_TOPO_PACKAGE_ID);
|
||||
if(status) {
|
||||
// fill_array_from_sys completed successfully, but we
|
||||
// must to check the integrity of the package_ids array
|
||||
for(int i=0; i < total_cores; i++) {
|
||||
if(package_ids[i] == -1) {
|
||||
printWarn("fill_package_ids_from_sys: package_ids[%d] = -1", i);
|
||||
return false;
|
||||
}
|
||||
else if(package_ids[i] >= total_cores || package_ids[i] < 0) {
|
||||
printBug("fill_package_ids_from_sys: package_ids[%d] = %d", i, package_ids[i]);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
long get_frequency_from_cpuinfo(void) {
|
||||
char* freq_str = get_field_from_cpuinfo(CPUINFO_FREQUENCY_STR);
|
||||
if(freq_str == NULL) {
|
||||
return UNKNOWN_DATA;
|
||||
}
|
||||
else {
|
||||
// freq_str should be in the form XXXX.YYYYYYMHz
|
||||
char* dot = strstr(freq_str, ".");
|
||||
freq_str[dot-freq_str] = '\0';
|
||||
|
||||
char* end;
|
||||
errno = 0;
|
||||
long ret = strtol(freq_str, &end, 10);
|
||||
if(errno != 0) {
|
||||
printBug("strtol: %s", strerror(errno));
|
||||
free(freq_str);
|
||||
return UNKNOWN_DATA;
|
||||
}
|
||||
|
||||
// We consider it an error if frequency is
|
||||
// greater than 10 GHz or less than 100 MHz
|
||||
if(ret > 10000 || ret < 100) {
|
||||
printBug("Invalid data was read from file '%s': %ld\n", CPUINFO_FREQUENCY_STR, ret);
|
||||
return UNKNOWN_DATA;
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
@@ -1,16 +0,0 @@
|
||||
#ifndef __UDEV_PPC__
|
||||
#define __UDEV_PPC__
|
||||
|
||||
#include "../common/udev.h"
|
||||
#define _PATH_DT "/proc/device-tree/vpd/root-node-vpd@a000/enclosure@1e00/backplane@800/processor@1000"
|
||||
#define _PATH_DT_PART "/part-number"
|
||||
#define _PATH_DT_IBM_PARTIT_NAME "/device-tree/ibm,partition-name"
|
||||
#define _PATH_DT_HMC_MANAGED "/device-tree/hmc-managed?"
|
||||
#define _PATH_DT_QEMU_WIDTH "/device-tree/chosen/qemu,graphic-width"
|
||||
|
||||
bool fill_core_ids_from_sys(int *core_ids, int total_cores);
|
||||
bool fill_package_ids_from_sys(int* package_ids, int total_cores);
|
||||
int get_num_sockets_package_cpus(struct topology* topo);
|
||||
long get_frequency_from_cpuinfo(void);
|
||||
|
||||
#endif
|
||||
@@ -1,206 +0,0 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <ctype.h>
|
||||
|
||||
#include "../common/global.h"
|
||||
#include "../common/udev.h"
|
||||
#include "udev.h"
|
||||
#include "uarch.h"
|
||||
#include "soc.h"
|
||||
|
||||
#define SET_ISA_EXT_MAP(name, bit) \
|
||||
if(strncmp(multi_letter_extension, name, \
|
||||
multi_letter_extension_len) == 0) { \
|
||||
ext->mask |= 1UL << bit; \
|
||||
maskset = true; \
|
||||
} \
|
||||
|
||||
struct frequency* get_frequency_info(uint32_t core) {
|
||||
struct frequency* freq = emalloc(sizeof(struct frequency));
|
||||
|
||||
freq->measured = false;
|
||||
freq->base = UNKNOWN_DATA;
|
||||
freq->max = get_max_freq_from_file(core);
|
||||
|
||||
return freq;
|
||||
}
|
||||
|
||||
int64_t get_peak_performance(struct cpuInfo* cpu) {
|
||||
//First check we have consistent data
|
||||
if(get_freq(cpu->freq) == UNKNOWN_DATA) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
int64_t flops = cpu->topo->total_cores * (get_freq(cpu->freq) * 1000000);
|
||||
return flops;
|
||||
}
|
||||
|
||||
// Returns the length of the multi-letter
|
||||
// extension, or -1 if an error occurs
|
||||
int parse_multi_letter_extension(struct extensions* ext, char* e) {
|
||||
if(*e != '_') return -1;
|
||||
char* multi_letter_extension_end = strstr(e+1, "_");
|
||||
if(multi_letter_extension_end == NULL) {
|
||||
// This is the last extension, find the end
|
||||
// of the string
|
||||
multi_letter_extension_end = e + strlen(e);
|
||||
}
|
||||
|
||||
int multi_letter_extension_len = multi_letter_extension_end-(e+1);
|
||||
bool maskset = false;
|
||||
char* multi_letter_extension = emalloc(multi_letter_extension_len);
|
||||
strncpy(multi_letter_extension, e+1, multi_letter_extension_len);
|
||||
// This should be up-to-date with
|
||||
// https://elixir.bootlin.com/linux/latest/source/arch/riscv/kernel/cpufeature.c
|
||||
// which should represent the list of extensions available in real chips
|
||||
SET_ISA_EXT_MAP("sscofpmf", RISCV_ISA_EXT_SSCOFPMF)
|
||||
SET_ISA_EXT_MAP("sstc", RISCV_ISA_EXT_SSTC)
|
||||
SET_ISA_EXT_MAP("svinval", RISCV_ISA_EXT_SVINVAL)
|
||||
SET_ISA_EXT_MAP("svpbmt", RISCV_ISA_EXT_SVPBMT)
|
||||
SET_ISA_EXT_MAP("zbb", RISCV_ISA_EXT_ZBB)
|
||||
SET_ISA_EXT_MAP("zicbom", RISCV_ISA_EXT_ZICBOM)
|
||||
SET_ISA_EXT_MAP("zihintpause", RISCV_ISA_EXT_ZIHINTPAUSE)
|
||||
SET_ISA_EXT_MAP("svnapot", RISCV_ISA_EXT_SVNAPOT)
|
||||
SET_ISA_EXT_MAP("zicboz", RISCV_ISA_EXT_ZICBOZ)
|
||||
SET_ISA_EXT_MAP("smaia", RISCV_ISA_EXT_SMAIA)
|
||||
SET_ISA_EXT_MAP("ssaia", RISCV_ISA_EXT_SSAIA)
|
||||
SET_ISA_EXT_MAP("zba", RISCV_ISA_EXT_ZBA)
|
||||
SET_ISA_EXT_MAP("zbs", RISCV_ISA_EXT_ZBS)
|
||||
SET_ISA_EXT_MAP("zicntr", RISCV_ISA_EXT_ZICNTR)
|
||||
SET_ISA_EXT_MAP("zicsr", RISCV_ISA_EXT_ZICSR)
|
||||
SET_ISA_EXT_MAP("zifencei", RISCV_ISA_EXT_ZIFENCEI)
|
||||
SET_ISA_EXT_MAP("zihpm", RISCV_ISA_EXT_ZIHPM)
|
||||
if(!maskset) {
|
||||
printBug("parse_multi_letter_extension: Unknown multi-letter extension: %s", multi_letter_extension);
|
||||
return -1;
|
||||
}
|
||||
|
||||
return multi_letter_extension_len;
|
||||
}
|
||||
|
||||
bool valid_extension(char ext) {
|
||||
bool found = false;
|
||||
uint64_t idx = 0;
|
||||
|
||||
while(idx < sizeof(extension_list)/sizeof(extension_list[0]) && !found) {
|
||||
found = (extension_list[idx].id == (ext - 'a'));
|
||||
if(!found) idx++;
|
||||
}
|
||||
|
||||
return found;
|
||||
}
|
||||
|
||||
struct extensions* get_extensions_from_str(char* str) {
|
||||
struct extensions* ext = emalloc(sizeof(struct extensions));
|
||||
ext->mask = 0;
|
||||
ext->str = NULL;
|
||||
|
||||
if(str == NULL) {
|
||||
return ext;
|
||||
}
|
||||
|
||||
int len = strlen(str);
|
||||
ext->str = ecalloc(len+1, sizeof(char));
|
||||
strncpy(ext->str, str, sizeof(char) * len);
|
||||
|
||||
// Code inspired in Linux kernel (riscv_fill_hwcap):
|
||||
// https://elixir.bootlin.com/linux/v6.2.10/source/arch/riscv/kernel/cpufeature.c
|
||||
char* isa = str;
|
||||
if (!strncmp(isa, "rv32", 4))
|
||||
isa += 4;
|
||||
else if (!strncmp(isa, "rv64", 4))
|
||||
isa += 4;
|
||||
else {
|
||||
printBug("get_extensions_from_str: ISA string must start with rv64 or rv32");
|
||||
return ext;
|
||||
}
|
||||
|
||||
for(char* e = isa; *e != '\0'; e++) {
|
||||
if(*e == '_') {
|
||||
// Multi-letter extension
|
||||
int multi_letter_extension_len = parse_multi_letter_extension(ext, e);
|
||||
if(multi_letter_extension_len == -1) {
|
||||
return ext;
|
||||
}
|
||||
e += multi_letter_extension_len;
|
||||
}
|
||||
else {
|
||||
// Single-letter extensions 's' and 'u' are invalid
|
||||
// according to Linux kernel (arch/riscv/kernel/cpufeature.c:
|
||||
// riscv_fill_hwcap). Optionally, we could opt for using
|
||||
// hwcap instead of cpuinfo to avoid this
|
||||
if (*e == 's' || *e == 'u') {
|
||||
continue;
|
||||
}
|
||||
// Make sure that the extension is valid before
|
||||
// adding it to the mask
|
||||
if(valid_extension(*e)) {
|
||||
int n = *e - 'a';
|
||||
ext->mask |= 1UL << n;
|
||||
}
|
||||
else {
|
||||
printBug("get_extensions_from_str: Invalid extension: '%c'", *e);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return ext;
|
||||
}
|
||||
|
||||
struct cpuInfo* get_cpu_info(void) {
|
||||
struct cpuInfo* cpu = malloc(sizeof(struct cpuInfo));
|
||||
//init_cpu_info(cpu);
|
||||
struct topology* topo = emalloc(sizeof(struct topology));
|
||||
topo->total_cores = get_ncores_from_cpuinfo();
|
||||
topo->cach = NULL;
|
||||
cpu->topo = topo;
|
||||
|
||||
char* cpuinfo_str = get_uarch_from_cpuinfo();
|
||||
char* ext_str = get_extensions_from_cpuinfo();
|
||||
cpu->hv = emalloc(sizeof(struct hypervisor));
|
||||
cpu->hv->present = false;
|
||||
cpu->ext = get_extensions_from_str(ext_str);
|
||||
if(cpu->ext->str != NULL && cpu->ext->mask == 0) return NULL;
|
||||
cpu->arch = get_uarch_from_cpuinfo_str(cpuinfo_str, cpu);
|
||||
cpu->soc = get_soc(cpu);
|
||||
cpu->freq = get_frequency_info(0);
|
||||
cpu->peak_performance = get_peak_performance(cpu);
|
||||
|
||||
return cpu;
|
||||
}
|
||||
|
||||
//TODO: Might be worth refactoring with other archs
|
||||
char* get_str_topology(struct cpuInfo* cpu, struct topology* topo) {
|
||||
uint32_t size = 3+7+1;
|
||||
char* string = emalloc(sizeof(char)*size);
|
||||
snprintf(string, size, "%d cores", topo->total_cores);
|
||||
|
||||
return string;
|
||||
}
|
||||
|
||||
char* get_str_extensions(struct cpuInfo* cpu) {
|
||||
if(cpu->ext != NULL) {
|
||||
return cpu->ext->str;
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
void print_debug(struct cpuInfo* cpu) {
|
||||
printf("- soc: ");
|
||||
if(cpu->soc->raw_name == NULL) {
|
||||
printf("NULL\n");
|
||||
}
|
||||
else {
|
||||
printf("'%s'\n", cpu->soc->raw_name);
|
||||
}
|
||||
|
||||
printf("- uarch: ");
|
||||
char* arch_cpuinfo_str = get_arch_cpuinfo_str(cpu);
|
||||
if(arch_cpuinfo_str == NULL) {
|
||||
printf("NULL\n");
|
||||
}
|
||||
else {
|
||||
printf("'%s'\n", arch_cpuinfo_str);
|
||||
}
|
||||
}
|
||||
@@ -1,82 +0,0 @@
|
||||
#ifndef __RISCV__
|
||||
#define __RISCV__
|
||||
|
||||
#include "../common/cpu.h"
|
||||
|
||||
struct extension {
|
||||
int id;
|
||||
char* str;
|
||||
};
|
||||
|
||||
#define RISCV_ISA_EXT_NAME_LEN_MAX 32
|
||||
#define RISCV_ISA_EXT_BASE 26
|
||||
|
||||
// https://elixir.bootlin.com/linux/latest/source/arch/riscv/include/asm/hwcap.h
|
||||
// This enum represent the logical ID for multi-letter RISC-V ISA extensions.
|
||||
// The logical ID should start from RISCV_ISA_EXT_BASE
|
||||
enum riscv_isa_ext_id {
|
||||
RISCV_ISA_EXT_SSCOFPMF = RISCV_ISA_EXT_BASE,
|
||||
RISCV_ISA_EXT_SSTC,
|
||||
RISCV_ISA_EXT_SVINVAL,
|
||||
RISCV_ISA_EXT_SVPBMT,
|
||||
RISCV_ISA_EXT_ZBB,
|
||||
RISCV_ISA_EXT_ZICBOM,
|
||||
RISCV_ISA_EXT_ZIHINTPAUSE,
|
||||
RISCV_ISA_EXT_SVNAPOT,
|
||||
RISCV_ISA_EXT_ZICBOZ,
|
||||
RISCV_ISA_EXT_SMAIA,
|
||||
RISCV_ISA_EXT_SSAIA,
|
||||
RISCV_ISA_EXT_ZBA,
|
||||
RISCV_ISA_EXT_ZBS,
|
||||
RISCV_ISA_EXT_ZICNTR,
|
||||
RISCV_ISA_EXT_ZICSR,
|
||||
RISCV_ISA_EXT_ZIFENCEI,
|
||||
RISCV_ISA_EXT_ZIHPM,
|
||||
RISCV_ISA_EXT_ID_MAX
|
||||
};
|
||||
|
||||
// https://five-embeddev.com/riscv-isa-manual/latest/preface.html#preface
|
||||
// https://en.wikichip.org/wiki/risc-v/standard_extensions
|
||||
// Included all except for G
|
||||
static const struct extension extension_list[] = {
|
||||
{ 'i' - 'a', "(I) Integer Instruction Set" },
|
||||
{ 'm' - 'a', "(M) Integer Multiplication and Division" },
|
||||
{ 'a' - 'a', "(A) Atomic Instructions" },
|
||||
{ 'f' - 'a', "(F) Single-Precision Floating-Point" },
|
||||
{ 'd' - 'a', "(D) Double-Precision Floating-Point" },
|
||||
{ 'q' - 'a', "(Q) Quad-Precision Floating-Point" },
|
||||
{ 'l' - 'a', "(L) Decimal Floating-Point" },
|
||||
{ 'c' - 'a', "(C) Compressed Instructions" },
|
||||
{ 'b' - 'a', "(B) Double-Precision Floating-Point" },
|
||||
{ 'j' - 'a', "(J) Dynamically Translated Languages" },
|
||||
{ 't' - 'a', "(T) Transactional Memory" },
|
||||
{ 'p' - 'a', "(P) Packed-SIMD Instructions" },
|
||||
{ 'v' - 'a', "(V) Vector Operations" },
|
||||
{ 'n' - 'a', "(N) User-Level Interrupts" },
|
||||
{ 'h' - 'a', "(H) Hypervisor" },
|
||||
// multi-letter extensions
|
||||
{ RISCV_ISA_EXT_SSCOFPMF, "(Sscofpmf) Count OverFlow and Privilege Mode Filtering" },
|
||||
{ RISCV_ISA_EXT_SSTC, "(Sstc) S and VS level Time Compare" },
|
||||
{ RISCV_ISA_EXT_SVINVAL, "(Svinval) Fast TLB Invalidation" },
|
||||
{ RISCV_ISA_EXT_SVPBMT, "(Svpbmt) Page-based Memory Types" },
|
||||
{ RISCV_ISA_EXT_ZBB, "(Zbb) Basic bit-manipulation" },
|
||||
{ RISCV_ISA_EXT_ZICBOM, "(Zicbom) Cache Block Management Operations" },
|
||||
{ RISCV_ISA_EXT_ZIHINTPAUSE, "(Zihintpause) Pause Hint" },
|
||||
{ RISCV_ISA_EXT_SVNAPOT, "(Svnapot) Naturally Aligned Power of Two Pages" },
|
||||
{ RISCV_ISA_EXT_ZICBOZ, "(Zicboz) Cache Block Zero Operations" },
|
||||
{ RISCV_ISA_EXT_SMAIA, "(Smaia) Advanced Interrupt Architecture" },
|
||||
{ RISCV_ISA_EXT_SSAIA, "(Ssaia) Advanced Interrupt Architecture" },
|
||||
{ RISCV_ISA_EXT_ZBA, "(Zba) Address Generation" },
|
||||
{ RISCV_ISA_EXT_ZBS, "(Zbs) Single-bit Instructions" },
|
||||
{ RISCV_ISA_EXT_ZICNTR, "(Zicntr) Base Counters and Timers" },
|
||||
{ RISCV_ISA_EXT_ZICSR, "(Zicsr) Control and Status Register" },
|
||||
{ RISCV_ISA_EXT_ZIFENCEI, "(Zifencei) Instruction-Fetch Fence" },
|
||||
{ RISCV_ISA_EXT_ZIHPM, "(Zihpm) Hardware Performance Counters" }
|
||||
};
|
||||
|
||||
struct cpuInfo* get_cpu_info(void);
|
||||
char* get_str_topology(struct cpuInfo* cpu, struct topology* topo);
|
||||
char* get_str_extensions(struct cpuInfo* cpu);
|
||||
void print_debug(struct cpuInfo* cpu);
|
||||
|
||||
#endif
|
||||
@@ -1,93 +0,0 @@
|
||||
#include "soc.h"
|
||||
#include "socs.h"
|
||||
#include "udev.h"
|
||||
#include "../common/global.h"
|
||||
|
||||
#include <string.h>
|
||||
|
||||
bool match_sifive(char* soc_name, struct system_on_chip* soc) {
|
||||
char* tmp = soc_name;
|
||||
|
||||
// Dont know if it makes sense in RISC-V
|
||||
/*if((tmp = strstr(soc_name, "???")) == NULL)
|
||||
return false;*/
|
||||
|
||||
//soc->vendor = ???
|
||||
|
||||
SOC_START
|
||||
SOC_EQ(tmp, "fu740", "Freedom U740", SOC_SIFIVE_U740, soc, 40)
|
||||
SOC_END
|
||||
}
|
||||
|
||||
bool match_starfive(char* soc_name, struct system_on_chip* soc) {
|
||||
SOC_START
|
||||
SOC_EQ(soc_name, "jh7110#", "VisionFive 2", SOC_STARFIVE_VF2, soc, 28) // https://blog.bitsofnetworks.org/benchmarking-risc-v-visionfive-2-vs-the-world.html
|
||||
SOC_EQ(soc_name, "jh7110", "VisionFive 2", SOC_STARFIVE_VF2, soc, 28)
|
||||
SOC_END
|
||||
}
|
||||
|
||||
bool match_allwinner(char* soc_name, struct system_on_chip* soc) {
|
||||
SOC_START
|
||||
SOC_EQ(soc_name, "sun20i-d1", "D1-H", SOC_ALLWINNER_D1H, soc, 22)
|
||||
SOC_END
|
||||
}
|
||||
|
||||
bool match_sipeed(char* soc_name, struct system_on_chip* soc) {
|
||||
SOC_START
|
||||
SOC_EQ(soc_name, "light", "Lichee Pi 4A", SOC_SIPEED_LICHEEPI4A, soc, 12) // https://github.com/Dr-Noob/cpufetch/issues/200, https://sipeed.com/licheepi4a
|
||||
SOC_END
|
||||
}
|
||||
|
||||
struct system_on_chip* parse_soc_from_string(struct system_on_chip* soc) {
|
||||
char* raw_name = soc->raw_name;
|
||||
|
||||
if(match_starfive(raw_name, soc))
|
||||
return soc;
|
||||
|
||||
if(match_allwinner(raw_name, soc))
|
||||
return soc;
|
||||
|
||||
if(match_sifive(raw_name, soc))
|
||||
return soc;
|
||||
|
||||
match_sipeed(raw_name, soc);
|
||||
return soc;
|
||||
}
|
||||
|
||||
struct system_on_chip* guess_soc_from_devtree(struct system_on_chip* soc) {
|
||||
char* tmp = get_hardware_from_devtree();
|
||||
|
||||
if(tmp != NULL) {
|
||||
soc->raw_name = tmp;
|
||||
return parse_soc_from_string(soc);
|
||||
}
|
||||
|
||||
return soc;
|
||||
}
|
||||
|
||||
struct system_on_chip* get_soc(struct cpuInfo* cpu) {
|
||||
struct system_on_chip* soc = emalloc(sizeof(struct system_on_chip));
|
||||
soc->raw_name = NULL;
|
||||
soc->vendor = SOC_VENDOR_UNKNOWN;
|
||||
soc->model = SOC_MODEL_UNKNOWN;
|
||||
soc->process = UNKNOWN;
|
||||
|
||||
soc = guess_soc_from_devtree(soc);
|
||||
if(soc->vendor == SOC_VENDOR_UNKNOWN) {
|
||||
if(soc->raw_name != NULL) {
|
||||
printWarn("SoC detection failed using device tree: Found '%s' string", soc->raw_name);
|
||||
}
|
||||
else {
|
||||
printWarn("SoC detection failed using device tree");
|
||||
}
|
||||
}
|
||||
|
||||
if(soc->model == SOC_MODEL_UNKNOWN) {
|
||||
// raw_name might not be NULL, but if we were unable to find
|
||||
// the exact SoC, just print "Unkwnown"
|
||||
soc->raw_name = emalloc(sizeof(char) * (strlen(STRING_UNKNOWN)+1));
|
||||
snprintf(soc->raw_name, strlen(STRING_UNKNOWN)+1, STRING_UNKNOWN);
|
||||
}
|
||||
|
||||
return soc;
|
||||
}
|
||||
@@ -1,10 +0,0 @@
|
||||
#ifndef __SOC_RISCV__
|
||||
#define __SOC_RISCV__
|
||||
|
||||
#include "../common/soc.h"
|
||||
#include "../common/cpu.h"
|
||||
#include <stdint.h>
|
||||
|
||||
struct system_on_chip* get_soc(struct cpuInfo* cpu);
|
||||
|
||||
#endif
|
||||
@@ -1,28 +0,0 @@
|
||||
#ifndef __SOCS__
|
||||
#define __SOCS__
|
||||
|
||||
#include "soc.h"
|
||||
|
||||
// List of supported SOCs
|
||||
enum {
|
||||
// SIFIVE
|
||||
SOC_SIFIVE_U740,
|
||||
// STARFIVE
|
||||
SOC_STARFIVE_VF2,
|
||||
// ALLWINNER
|
||||
SOC_ALLWINNER_D1H,
|
||||
// SIPEED
|
||||
SOC_SIPEED_LICHEEPI4A,
|
||||
// UNKNOWN
|
||||
SOC_MODEL_UNKNOWN
|
||||
};
|
||||
|
||||
inline static VENDOR get_soc_vendor_from_soc(SOC soc) {
|
||||
if(soc >= SOC_SIFIVE_U740 && soc <= SOC_SIFIVE_U740) return SOC_VENDOR_SIFIVE;
|
||||
if(soc >= SOC_STARFIVE_VF2 && soc <= SOC_STARFIVE_VF2) return SOC_VENDOR_STARFIVE;
|
||||
if(soc >= SOC_ALLWINNER_D1H && soc <= SOC_ALLWINNER_D1H) return SOC_VENDOR_ALLWINNER;
|
||||
if(soc >= SOC_SIPEED_LICHEEPI4A && soc <= SOC_SIPEED_LICHEEPI4A) return SOC_VENDOR_SIPEED;
|
||||
return SOC_VENDOR_UNKNOWN;
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -1,84 +0,0 @@
|
||||
#include <stdbool.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "uarch.h"
|
||||
#include "../common/global.h"
|
||||
|
||||
typedef uint32_t MICROARCH;
|
||||
|
||||
struct uarch {
|
||||
MICROARCH uarch;
|
||||
char* uarch_str;
|
||||
char* cpuinfo_str;
|
||||
};
|
||||
|
||||
enum {
|
||||
UARCH_UNKNOWN,
|
||||
// SIFIVE
|
||||
UARCH_U54,
|
||||
UARCH_U74,
|
||||
// THEAD
|
||||
UARCH_C906,
|
||||
UARCH_C910
|
||||
};
|
||||
|
||||
#define UARCH_START if (false) {}
|
||||
#define CHECK_UARCH(arch, cpu, cpuinfo_str, uarch_str, str, uarch, vendor) \
|
||||
else if (strcmp(cpuinfo_str, uarch_str) == 0) fill_uarch(arch, cpu, str, uarch, vendor);
|
||||
#define UARCH_END else { printBug("Unknown microarchitecture detected: uarch='%s'", cpuinfo_str); fill_uarch(arch, cpu, "Unknown", UARCH_UNKNOWN, CPU_VENDOR_UNKNOWN); }
|
||||
|
||||
void fill_uarch(struct uarch* arch, struct cpuInfo* cpu, char* str, MICROARCH u, VENDOR vendor) {
|
||||
arch->uarch = u;
|
||||
cpu->cpu_vendor = vendor;
|
||||
arch->uarch_str = emalloc(sizeof(char) * (strlen(str)+1));
|
||||
strcpy(arch->uarch_str, str);
|
||||
}
|
||||
|
||||
// https://elixir.bootlin.com/linux/latest/source/Documentation/devicetree/bindings/riscv/cpus.yaml
|
||||
// SiFive: https://www.sifive.com/risc-v-core-ip
|
||||
// T-Head: https://www.t-head.cn/product/c906
|
||||
struct uarch* get_uarch_from_cpuinfo_str(char* cpuinfo_str, struct cpuInfo* cpu) {
|
||||
struct uarch* arch = emalloc(sizeof(struct uarch));
|
||||
arch->cpuinfo_str = cpuinfo_str;
|
||||
if(cpuinfo_str == NULL) {
|
||||
printWarn("get_uarch_from_cpuinfo: Unable to detect microarchitecture, cpuinfo_str is NULL");
|
||||
fill_uarch(arch, cpu, "Unknown", UARCH_UNKNOWN, CPU_VENDOR_UNKNOWN);
|
||||
return arch;
|
||||
}
|
||||
|
||||
// U74/U74-MC:
|
||||
// SiFive says that U74-MC is "Multicore: four U74 cores and one S76 core" while
|
||||
// U74 is "High performance Linux-capable processor". It's like U74-MC is somehow a small SoC containing
|
||||
// the U74 and the S76? Then U74-MC is not a microarchitecture per se...
|
||||
UARCH_START
|
||||
CHECK_UARCH(arch, cpu, cpuinfo_str, "sifive,bullet0", "U74", UARCH_U74, CPU_VENDOR_SIFIVE) // bullet0 is present in U740, which has U74
|
||||
// CHECK_UARCH(arch, cpu, cpuinfo_str, "sifive,e5", "XXXXXX", UARCH_U74, CPU_VENDOR_SIFIVE)
|
||||
// CHECK_UARCH(arch, cpu, cpuinfo_str, "sifive,e7", "XXXXXX", UARCH_U74, CPU_VENDOR_SIFIVE)
|
||||
// CHECK_UARCH(arch, cpu, cpuinfo_str, "sifive,e71", "XXXXXX", UARCH_U74, CPU_VENDOR_SIFIVE)
|
||||
// CHECK_UARCH(arch, cpu, cpuinfo_str, "sifive,rocket0", "XXXXXX", UARCH_U74, CPU_VENDOR_SIFIVE)
|
||||
// CHECK_UARCH(arch, cpu, cpuinfo_str, "sifive,u5", "XXXXXX", UARCH_U74, CPU_VENDOR_SIFIVE)
|
||||
CHECK_UARCH(arch, cpu, cpuinfo_str, "sifive,u54", "U54", UARCH_U54, CPU_VENDOR_SIFIVE)
|
||||
// CHECK_UARCH(arch, cpu, cpuinfo_str, "sifive,u7", "XXXXXX", UARCH_U74, CPU_VENDOR_SIFIVE)
|
||||
CHECK_UARCH(arch, cpu, cpuinfo_str, "sifive,u74", "U74", UARCH_U74, CPU_VENDOR_SIFIVE)
|
||||
CHECK_UARCH(arch, cpu, cpuinfo_str, "sifive,u74-mc", "U74", UARCH_U74, CPU_VENDOR_SIFIVE)
|
||||
CHECK_UARCH(arch, cpu, cpuinfo_str, "thead,c906", "T-Head C906", UARCH_C906, CPU_VENDOR_THEAD)
|
||||
CHECK_UARCH(arch, cpu, cpuinfo_str, "thead,c910", "T-Head C910", UARCH_C910, CPU_VENDOR_THEAD)
|
||||
UARCH_END
|
||||
|
||||
return arch;
|
||||
}
|
||||
|
||||
char* get_str_uarch(struct cpuInfo* cpu) {
|
||||
return cpu->arch->uarch_str;
|
||||
}
|
||||
|
||||
char* get_arch_cpuinfo_str(struct cpuInfo* cpu) {
|
||||
return cpu->arch->cpuinfo_str;
|
||||
}
|
||||
|
||||
void free_uarch_struct(struct uarch* arch) {
|
||||
free(arch->uarch_str);
|
||||
free(arch);
|
||||
}
|
||||
@@ -1,14 +0,0 @@
|
||||
#ifndef __UARCH__
|
||||
#define __UARCH__
|
||||
|
||||
#include <stdint.h>
|
||||
#include "riscv.h"
|
||||
|
||||
struct uarch;
|
||||
|
||||
char* get_arch_cpuinfo_str(struct cpuInfo* cpu);
|
||||
char* get_str_uarch(struct cpuInfo* cpu);
|
||||
void free_uarch_struct(struct uarch* arch);
|
||||
struct uarch* get_uarch_from_cpuinfo_str(char* cpuinfo_str, struct cpuInfo* cpu);
|
||||
|
||||
#endif
|
||||
@@ -1,89 +0,0 @@
|
||||
#include <errno.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "../common/global.h"
|
||||
#include "udev.h"
|
||||
|
||||
#define _PATH_DEVTREE "/proc/device-tree/compatible"
|
||||
#define CPUINFO_UARCH_STR "uarch\t\t: "
|
||||
#define CPUINFO_EXTENSIONS_STR "isa\t\t: "
|
||||
#define DEVTREE_HARDWARE_FIELD 0
|
||||
|
||||
char* get_field_from_devtree(int DEVTREE_FIELD) {
|
||||
int filelen;
|
||||
char* buf;
|
||||
if((buf = read_file(_PATH_DEVTREE, &filelen)) == NULL) {
|
||||
printWarn("read_file: %s: %s", _PATH_DEVTREE, strerror(errno));
|
||||
return NULL;
|
||||
}
|
||||
|
||||
// Here we would use strstr to find the comma.
|
||||
// However, the device-tree file may contain NULL
|
||||
// bytes in the middle of the string, which would
|
||||
// cause strstr to return NULL even when there might
|
||||
// be an occurence after the NULL byte
|
||||
//
|
||||
// We iterate the string backwards to find the field
|
||||
// in position n-DEVTREE_HARDWARE_FIELD where n
|
||||
// is the number of fields.
|
||||
int i=0;
|
||||
char* tmp1 = buf+filelen-1;
|
||||
do {
|
||||
tmp1--;
|
||||
if(*tmp1 == ',') i++;
|
||||
} while(tmp1 != buf && i <= DEVTREE_FIELD);
|
||||
|
||||
if(tmp1 == buf) {
|
||||
printWarn("get_field_from_devtree: Unable to find field %d", DEVTREE_FIELD);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
tmp1++;
|
||||
int strlen = filelen-(tmp1-buf);
|
||||
char* hardware = ecalloc(strlen, sizeof(char));
|
||||
strncpy(hardware, tmp1, strlen-1);
|
||||
|
||||
return hardware;
|
||||
}
|
||||
|
||||
char* parse_cpuinfo_field(char* field_str) {
|
||||
int filelen;
|
||||
char* buf;
|
||||
if((buf = read_file(_PATH_CPUINFO, &filelen)) == NULL) {
|
||||
printWarn("read_file: %s: %s", _PATH_CPUINFO, strerror(errno));
|
||||
return NULL;
|
||||
}
|
||||
|
||||
char* tmp = strstr(buf, field_str);
|
||||
if(tmp == NULL) {
|
||||
printWarn("parse_cpuinfo_field: Unable to find field %s", field_str);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
tmp += strlen(field_str);
|
||||
char* end = strstr(tmp, "\n");
|
||||
|
||||
if(end == NULL) {
|
||||
printWarn("parse_cpuinfo_field: Unable to find newline after field %s", field_str);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
int ret_strlen = (end-tmp);
|
||||
char* ret = ecalloc(ret_strlen+1, sizeof(char));
|
||||
strncpy(ret, tmp, sizeof(char) * ret_strlen);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
char* get_hardware_from_devtree(void) {
|
||||
return get_field_from_devtree(DEVTREE_HARDWARE_FIELD);
|
||||
}
|
||||
|
||||
char* get_uarch_from_cpuinfo(void) {
|
||||
return parse_cpuinfo_field(CPUINFO_UARCH_STR);
|
||||
}
|
||||
|
||||
char* get_extensions_from_cpuinfo(void) {
|
||||
return parse_cpuinfo_field(CPUINFO_EXTENSIONS_STR);
|
||||
}
|
||||
|
||||
@@ -1,12 +0,0 @@
|
||||
#ifndef __UDEV_RISCV__
|
||||
#define __UDEV_RISCV__
|
||||
|
||||
#include "../common/udev.h"
|
||||
|
||||
#define UNKNOWN -1
|
||||
|
||||
char* get_hardware_from_devtree(void);
|
||||
char* get_uarch_from_cpuinfo(void);
|
||||
char* get_extensions_from_cpuinfo(void);
|
||||
|
||||
#endif
|
||||
183
src/x86/apic.c
183
src/x86/apic.c
@@ -1,12 +1,10 @@
|
||||
#ifdef _WIN32
|
||||
#define NOMINMAX
|
||||
#include <windows.h>
|
||||
#elif defined __linux__
|
||||
#define _GNU_SOURCE
|
||||
#include <sched.h>
|
||||
#elif defined __FreeBSD__
|
||||
#include <sys/param.h>
|
||||
#include <sys/cpuset.h>
|
||||
#elif defined __APPLE__
|
||||
#define UNUSED(x) (void)(x)
|
||||
#endif
|
||||
|
||||
#include <stdlib.h>
|
||||
@@ -14,7 +12,6 @@
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
#include <unistd.h>
|
||||
#include <errno.h>
|
||||
|
||||
#include "apic.h"
|
||||
#include "cpuid_asm.h"
|
||||
@@ -26,7 +23,7 @@
|
||||
*/
|
||||
unsigned char bit_scan_reverse(uint32_t* index, uint64_t mask) {
|
||||
for(uint64_t i = (8 * sizeof(uint64_t)); i > 0; i--) {
|
||||
if((mask & (1ULL << (i-1))) != 0) {
|
||||
if((mask & (1LL << (i-1))) != 0) {
|
||||
*index = (uint64_t) (i-1);
|
||||
break;
|
||||
}
|
||||
@@ -72,58 +69,22 @@ uint32_t get_apic_id(bool x2apic_id) {
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef __linux__
|
||||
int get_total_cores_module(int total_cores, int module) {
|
||||
int total_modules = 2;
|
||||
int32_t current_module_idx = -1;
|
||||
bool end = false;
|
||||
int32_t* core_types = emalloc(sizeof(uint32_t) * total_modules);
|
||||
for(int i=0; i < total_modules; i++) core_types[i] = -1;
|
||||
int cores_in_module = 0;
|
||||
int i = 0;
|
||||
|
||||
// Get the original mask to restore it later
|
||||
cpu_set_t original_mask;
|
||||
if(sched_getaffinity(0, sizeof(original_mask), &original_mask) == -1) {
|
||||
printWarn("sched_getaffinity: %s", strerror(errno));
|
||||
#ifndef __APPLE__
|
||||
bool bind_to_cpu(int cpu_id) {
|
||||
#ifdef _WIN32
|
||||
HANDLE process = GetCurrentProcess();
|
||||
DWORD_PTR processAffinityMask = 1 << cpu_id;
|
||||
return SetProcessAffinityMask(process, processAffinityMask);
|
||||
#else
|
||||
cpu_set_t currentCPU;
|
||||
CPU_ZERO(¤tCPU);
|
||||
CPU_SET(cpu_id, ¤tCPU);
|
||||
if (sched_setaffinity (0, sizeof(currentCPU), ¤tCPU) == -1) {
|
||||
perror("sched_setaffinity");
|
||||
return false;
|
||||
}
|
||||
|
||||
while(!end) {
|
||||
if(!bind_to_cpu(i)) {
|
||||
return -1;
|
||||
}
|
||||
uint32_t eax = 0x0000001A;
|
||||
uint32_t ebx = 0;
|
||||
uint32_t ecx = 0;
|
||||
uint32_t edx = 0;
|
||||
cpuid(&eax, &ebx, &ecx, &edx);
|
||||
int32_t core_type = eax >> 24 & 0xFF;
|
||||
bool found = false;
|
||||
|
||||
for(int j=0; j < total_modules && !found; j++) {
|
||||
if(core_types[j] == core_type) found = true;
|
||||
}
|
||||
if(!found) {
|
||||
current_module_idx++;
|
||||
core_types[current_module_idx] = core_type;
|
||||
}
|
||||
if(current_module_idx == module) {
|
||||
cores_in_module++;
|
||||
if(i+1 == total_cores) end = true;
|
||||
}
|
||||
else if(cores_in_module > 0) end = true;
|
||||
i++;
|
||||
}
|
||||
|
||||
// Reset the original affinity
|
||||
if (sched_setaffinity (0, sizeof(original_mask), &original_mask) == -1) {
|
||||
printWarn("sched_setaffinity: %s", strerror(errno));
|
||||
return false;
|
||||
}
|
||||
|
||||
//printf("Module %d has %d cores\n", module, cores_in_module);
|
||||
return cores_in_module;
|
||||
return true;
|
||||
#endif
|
||||
}
|
||||
#endif
|
||||
|
||||
@@ -222,36 +183,40 @@ uint32_t max_apic_id_size(uint32_t** cache_id_apic, struct topology* topo) {
|
||||
uint32_t max = 0;
|
||||
|
||||
for(int i=0; i < topo->cach->max_cache_level; i++) {
|
||||
for(int j=0; j < topo->total_cores_module; j++) {
|
||||
for(int j=0; j < topo->total_cores; j++) {
|
||||
if(cache_id_apic[j][i] > max) max = cache_id_apic[j][i];
|
||||
}
|
||||
}
|
||||
|
||||
max++;
|
||||
if(max > (uint32_t) topo->total_cores_module) return max;
|
||||
return topo->total_cores_module;
|
||||
if(max > (uint32_t) topo->total_cores) return max;
|
||||
return topo->total_cores;
|
||||
}
|
||||
|
||||
bool build_topo_from_apic(uint32_t* apic_pkg, uint32_t* apic_smt, uint32_t** cache_id_apic, struct topology* topo) {
|
||||
uint32_t size = max_apic_id_size(cache_id_apic, topo);
|
||||
uint32_t* sockets = ecalloc(size, sizeof(uint32_t));
|
||||
uint32_t* smt = ecalloc(size, sizeof(uint32_t));
|
||||
uint32_t* apic_id = ecalloc(size, sizeof(uint32_t));
|
||||
uint32_t* sockets = malloc(sizeof(uint32_t) * size);
|
||||
uint32_t* smt = malloc(sizeof(uint32_t) * size);
|
||||
uint32_t* apic_id = malloc(sizeof(uint32_t) * size);
|
||||
uint32_t num_caches = 0;
|
||||
|
||||
memset(sockets, 0, sizeof(uint32_t) * size);
|
||||
memset(smt, 0, sizeof(uint32_t) * size);
|
||||
memset(apic_id, 0, sizeof(uint32_t) * size);
|
||||
|
||||
// System topology
|
||||
for(int i=0; i < topo->total_cores_module; i++) {
|
||||
for(int i=0; i < topo->total_cores; i++) {
|
||||
sockets[apic_pkg[i]] = 1;
|
||||
smt[apic_smt[i]] = 1;
|
||||
}
|
||||
for(int i=0; i < topo->total_cores_module; i++) {
|
||||
for(int i=0; i < topo->total_cores; i++) {
|
||||
if(sockets[i] != 0)
|
||||
topo->sockets++;
|
||||
if(smt[i] != 0)
|
||||
topo->smt_available++;
|
||||
}
|
||||
|
||||
topo->logical_cores = topo->total_cores_module / topo->sockets;
|
||||
topo->logical_cores = topo->total_cores / topo->sockets;
|
||||
topo->physical_cores = topo->logical_cores / topo->smt_available;
|
||||
|
||||
// Cache topology
|
||||
@@ -259,7 +224,7 @@ bool build_topo_from_apic(uint32_t* apic_pkg, uint32_t* apic_smt, uint32_t** cac
|
||||
num_caches = 0;
|
||||
memset(apic_id, 0, sizeof(uint32_t) * size);
|
||||
|
||||
for(int c=0; c < topo->total_cores_module; c++) {
|
||||
for(int c=0; c < topo->total_cores; c++) {
|
||||
apic_id[cache_id_apic[c][i]]++;
|
||||
}
|
||||
for(uint32_t c=0; c < size; c++) {
|
||||
@@ -318,10 +283,9 @@ void add_apic_to_array(uint32_t apic, uint32_t* apic_ids, int n) {
|
||||
}
|
||||
}
|
||||
|
||||
bool fill_apic_ids(uint32_t* apic_ids, int first_core, int n, bool x2apic_id) {
|
||||
bool fill_apic_ids(uint32_t* apic_ids, int n, bool x2apic_id) {
|
||||
#ifdef __APPLE__
|
||||
// macOS extremely dirty approach...
|
||||
UNUSED(first_core);
|
||||
printf("cpufetch is computing APIC IDs, please wait...\n");
|
||||
bool end = false;
|
||||
uint32_t apic;
|
||||
@@ -335,71 +299,33 @@ bool fill_apic_ids(uint32_t* apic_ids, int first_core, int n, bool x2apic_id) {
|
||||
usleep(1000);
|
||||
}
|
||||
#else
|
||||
#ifdef __linux__
|
||||
// In Linux we reset the affinity; first we get the original mask
|
||||
cpu_set_t original_mask;
|
||||
if(sched_getaffinity(0, sizeof(original_mask), &original_mask) == -1) {
|
||||
printWarn("sched_getaffinity: %s", strerror(errno));
|
||||
return false;
|
||||
}
|
||||
#endif
|
||||
|
||||
for(int i=first_core; i < first_core+n; i++) {
|
||||
for(int i=0; i < n; i++) {
|
||||
if(!bind_to_cpu(i)) {
|
||||
printErr("Failed binding the process to CPU %d", i);
|
||||
printErr("Failed binding to CPU %d", i);
|
||||
return false;
|
||||
}
|
||||
apic_ids[i-first_core] = get_apic_id(x2apic_id);
|
||||
}
|
||||
|
||||
#ifdef __linux__
|
||||
// With the original mask previosly retrieved, we reset the affinity
|
||||
if (sched_setaffinity (0, sizeof(original_mask), &original_mask) == -1) {
|
||||
printWarn("sched_setaffinity: %s", strerror(errno));
|
||||
return false;
|
||||
apic_ids[i] = get_apic_id(x2apic_id);
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool get_topology_from_apic(struct cpuInfo* cpu, struct topology* topo) {
|
||||
if (topo->cach == NULL) {
|
||||
printWarn("get_topology_from_apic: cach is NULL");
|
||||
return false;
|
||||
}
|
||||
|
||||
uint32_t apic_id;
|
||||
uint32_t* apic_ids = emalloc(sizeof(uint32_t) * topo->total_cores_module);
|
||||
uint32_t* apic_pkg = emalloc(sizeof(uint32_t) * topo->total_cores_module);
|
||||
uint32_t* apic_core = emalloc(sizeof(uint32_t) * topo->total_cores_module);
|
||||
uint32_t* apic_smt = emalloc(sizeof(uint32_t) * topo->total_cores_module);
|
||||
uint32_t** cache_smt_id_apic = emalloc(sizeof(uint32_t*) * topo->total_cores_module);
|
||||
uint32_t** cache_id_apic = emalloc(sizeof(uint32_t*) * topo->total_cores_module);
|
||||
bool x2apic_id;
|
||||
uint32_t* apic_ids = malloc(sizeof(uint32_t) * topo->total_cores);
|
||||
uint32_t* apic_pkg = malloc(sizeof(uint32_t) * topo->total_cores);
|
||||
uint32_t* apic_core = malloc(sizeof(uint32_t) * topo->total_cores);
|
||||
uint32_t* apic_smt = malloc(sizeof(uint32_t) * topo->total_cores);
|
||||
uint32_t** cache_smt_id_apic = malloc(sizeof(uint32_t*) * topo->total_cores);
|
||||
uint32_t** cache_id_apic = malloc(sizeof(uint32_t*) * topo->total_cores);
|
||||
bool x2apic_id = cpu->maxLevels >= 0x0000000B;
|
||||
|
||||
if(cpu->maxLevels >= 0x0000000B) {
|
||||
uint32_t eax = 0x0000000B;
|
||||
uint32_t ebx = 0;
|
||||
uint32_t ecx = 0;
|
||||
uint32_t edx = 0;
|
||||
|
||||
cpuid(&eax, &ebx, &ecx, &edx);
|
||||
|
||||
if(ebx == 0) x2apic_id = false;
|
||||
else x2apic_id = true;
|
||||
for(int i=0; i < topo->total_cores; i++) {
|
||||
cache_smt_id_apic[i] = malloc(sizeof(uint32_t) * (topo->cach->max_cache_level));
|
||||
cache_id_apic[i] = malloc(sizeof(uint32_t) * (topo->cach->max_cache_level));
|
||||
}
|
||||
else {
|
||||
x2apic_id = false;
|
||||
}
|
||||
|
||||
for(int i=0; i < topo->total_cores_module; i++) {
|
||||
cache_smt_id_apic[i] = emalloc(sizeof(uint32_t) * (topo->cach->max_cache_level));
|
||||
cache_id_apic[i] = emalloc(sizeof(uint32_t) * (topo->cach->max_cache_level));
|
||||
}
|
||||
topo->apic->cache_select_mask = emalloc(sizeof(uint32_t) * (topo->cach->max_cache_level));
|
||||
topo->apic->cache_id_apic = emalloc(sizeof(uint32_t) * (topo->cach->max_cache_level));
|
||||
topo->apic->cache_select_mask = malloc(sizeof(uint32_t) * (topo->cach->max_cache_level));
|
||||
topo->apic->cache_id_apic = malloc(sizeof(uint32_t) * (topo->cach->max_cache_level));
|
||||
|
||||
if(x2apic_id) {
|
||||
if(!fill_topo_masks_x2apic(topo))
|
||||
@@ -412,10 +338,10 @@ bool get_topology_from_apic(struct cpuInfo* cpu, struct topology* topo) {
|
||||
|
||||
get_cache_topology_from_apic(topo);
|
||||
|
||||
if(!fill_apic_ids(apic_ids, cpu->first_core_id, topo->total_cores_module, x2apic_id))
|
||||
if(!fill_apic_ids(apic_ids, topo->total_cores, x2apic_id))
|
||||
return false;
|
||||
|
||||
for(int i=0; i < topo->total_cores_module; i++) {
|
||||
for(int i=0; i < topo->total_cores; i++) {
|
||||
apic_id = apic_ids[i];
|
||||
|
||||
apic_pkg[i] = (apic_id & topo->apic->pkg_mask) >> topo->apic->pkg_mask_shift;
|
||||
@@ -431,19 +357,20 @@ bool get_topology_from_apic(struct cpuInfo* cpu, struct topology* topo) {
|
||||
/* DEBUG
|
||||
for(int i=0; i < topo->cach->max_cache_level; i++) {
|
||||
printf("[CACH %1d]", i);
|
||||
for(int j=0; j < topo->total_cores_module; j++)
|
||||
for(int j=0; j < topo->total_cores; j++)
|
||||
printf("[%03d]", cache_id_apic[j][i]);
|
||||
printf("\n");
|
||||
}
|
||||
for(int i=0; i < topo->total_cores_module; i++)
|
||||
for(int i=0; i < topo->total_cores; i++)
|
||||
printf("[%2d] 0x%.8X\n", i, apic_pkg[i]);
|
||||
printf("\n");
|
||||
for(int i=0; i < topo->total_cores_module; i++)
|
||||
for(int i=0; i < topo->total_cores; i++)
|
||||
printf("[%2d] 0x%.8X\n", i, apic_core[i]);
|
||||
printf("\n");
|
||||
for(int i=0; i < topo->total_cores_module; i++)
|
||||
for(int i=0; i < topo->total_cores; i++)
|
||||
printf("[%2d] 0x%.8X\n", i, apic_smt[i]);*/
|
||||
|
||||
|
||||
bool ret = build_topo_from_apic(apic_pkg, apic_smt, cache_id_apic, topo);
|
||||
|
||||
// Assumption: If we cant get smt_available, we assume it is equal to smt_supported...
|
||||
@@ -455,7 +382,7 @@ bool get_topology_from_apic(struct cpuInfo* cpu, struct topology* topo) {
|
||||
free(apic_pkg);
|
||||
free(apic_core);
|
||||
free(apic_smt);
|
||||
for(int i=0; i < topo->total_cores_module; i++) {
|
||||
for(int i=0; i < topo->total_cores; i++) {
|
||||
free(cache_smt_id_apic[i]);
|
||||
free(cache_id_apic[i]);
|
||||
}
|
||||
|
||||
@@ -17,8 +17,4 @@ struct apic {
|
||||
bool get_topology_from_apic(struct cpuInfo* cpu, struct topology* topo);
|
||||
uint32_t is_smt_enabled_amd(struct topology* topo);
|
||||
|
||||
#ifdef __linux__
|
||||
int get_total_cores_module(int total_cores, int module);
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
912
src/x86/cpuid.c
Normal file → Executable file
912
src/x86/cpuid.c
Normal file → Executable file
File diff suppressed because it is too large
Load Diff
@@ -3,19 +3,18 @@
|
||||
|
||||
#include "../common/cpu.h"
|
||||
|
||||
struct cpuInfo* get_cpu_info(void);
|
||||
struct cpuInfo* get_cpu_info();
|
||||
struct cache* get_cache_info(struct cpuInfo* cpu);
|
||||
struct frequency* get_frequency_info(struct cpuInfo* cpu);
|
||||
struct topology* get_topology_info(struct cpuInfo* cpu, struct cache* cach, int module);
|
||||
struct topology* get_topology_info(struct cpuInfo* cpu, struct cache* cach);
|
||||
|
||||
char* get_str_avx(struct cpuInfo* cpu);
|
||||
char* get_str_sse(struct cpuInfo* cpu);
|
||||
char* get_str_fma(struct cpuInfo* cpu);
|
||||
char* get_str_topology(struct cpuInfo* cpu, struct topology* topo, bool dual_socket);
|
||||
char* get_str_cpu_name_abbreviated(struct cpuInfo* cpu);
|
||||
char* get_str_peak_performance(struct cpuInfo* cpu, struct topology* topo, int64_t freq);
|
||||
|
||||
void print_debug(struct cpuInfo* cpu);
|
||||
void print_raw(struct cpuInfo* cpu);
|
||||
|
||||
void free_topo_struct(struct topology* topo);
|
||||
|
||||
|
||||
@@ -1,192 +0,0 @@
|
||||
#define _GNU_SOURCE
|
||||
#include <stdio.h>
|
||||
|
||||
#include "../../common/global.h"
|
||||
#include "../uarch.h"
|
||||
#include "freq.h"
|
||||
#include "freq_nov.h"
|
||||
#include "freq_avx.h"
|
||||
#include "freq_avx512.h"
|
||||
|
||||
#include <immintrin.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdbool.h>
|
||||
#include <sys/time.h>
|
||||
#include <time.h>
|
||||
#include <errno.h>
|
||||
#include <string.h>
|
||||
#include <pthread.h>
|
||||
|
||||
#define MAX_NUMBER_THREADS 512
|
||||
#define FREQ_VECTOR_SIZE 1<<16
|
||||
|
||||
struct freq_thread {
|
||||
// Inputs
|
||||
struct cpuInfo* cpu;
|
||||
bool end;
|
||||
bool measure;
|
||||
// Output
|
||||
int32_t *max_pp;
|
||||
};
|
||||
|
||||
double vector_average_harmonic(double* v, int len) {
|
||||
double acc = 0.0;
|
||||
for(int i=0; i < len; i++) {
|
||||
acc += 1 / v[i];
|
||||
}
|
||||
return len / acc;
|
||||
}
|
||||
|
||||
void sleep_ms(int64_t ms) {
|
||||
struct timespec ts;
|
||||
ts.tv_sec = ms / 1000;
|
||||
ts.tv_nsec = (ms % 1000) * 1000000;
|
||||
nanosleep(&ts, &ts);
|
||||
}
|
||||
|
||||
void* measure_freq(void *freq_ptr) {
|
||||
struct freq_thread* freq = (struct freq_thread*) freq_ptr;
|
||||
|
||||
char* end = NULL;
|
||||
char* line = NULL;
|
||||
size_t len = 0;
|
||||
ssize_t read;
|
||||
struct cpuInfo* cpu = freq->cpu;
|
||||
|
||||
int v = 0;
|
||||
double* freq_vector = malloc(sizeof(double) * FREQ_VECTOR_SIZE);
|
||||
|
||||
while(!freq->end) {
|
||||
if(!freq->measure) continue;
|
||||
|
||||
FILE* fp = fopen("/proc/cpuinfo", "r");
|
||||
if(fp == NULL) return NULL;
|
||||
while ((read = getline(&line, &len, fp)) != -1) {
|
||||
if((line = strstr(line, "cpu MHz")) != NULL) {
|
||||
line = strstr(line, "\t: ");
|
||||
if(line == NULL) return NULL;
|
||||
line += sizeof("\t: ") - 1;
|
||||
double f = strtold(line, &end);
|
||||
if(errno != 0) {
|
||||
printf("strtol: %s", strerror(errno));
|
||||
return NULL;
|
||||
}
|
||||
|
||||
freq_vector[v] = f;
|
||||
v++;
|
||||
}
|
||||
}
|
||||
fclose(fp);
|
||||
sleep_ms(500);
|
||||
}
|
||||
|
||||
if (cpu->hybrid_flag) {
|
||||
// We have an heterogeneous architecture. After measuring the
|
||||
// frequency for all cores, we now need to compute the average
|
||||
// independently for each CPU module.
|
||||
struct cpuInfo* ptr = cpu;
|
||||
double* freq_vector_ptr = freq_vector;
|
||||
|
||||
for (int i=0; i < cpu->num_cpus; ptr = ptr->next_cpu, i++) {
|
||||
freq->max_pp[i] = vector_average_harmonic(freq_vector_ptr, ptr->topo->total_cores_module);
|
||||
printWarn("AVX2 measured freq=%d (module %d)", freq->max_pp[i], i);
|
||||
|
||||
freq_vector_ptr = freq_vector_ptr + ptr->topo->total_cores_module;
|
||||
}
|
||||
}
|
||||
else {
|
||||
freq->max_pp[0] = vector_average_harmonic(freq_vector, v);
|
||||
printWarn("AVX2 measured freq=%d\n", freq->max_pp[0]);
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
int32_t measure_frequency(struct cpuInfo* cpu, int32_t *max_freq_pp_vec) {
|
||||
if (cpu->hybrid_flag && cpu->module_id > 0) {
|
||||
// We have a hybrid architecture and we have already
|
||||
// measured the frequency for this module in a previous
|
||||
// call to this function, so now just return it.
|
||||
return max_freq_pp_vec[cpu->module_id];
|
||||
}
|
||||
|
||||
int ret;
|
||||
int num_spaces;
|
||||
struct freq_thread* freq_struct = malloc(sizeof(struct freq_thread));
|
||||
freq_struct->end = false;
|
||||
freq_struct->measure = false;
|
||||
freq_struct->cpu = cpu;
|
||||
freq_struct->max_pp = max_freq_pp_vec;
|
||||
|
||||
void* (*compute_function)(void*);
|
||||
|
||||
if(cpu->feat->AVX512 && vpus_are_AVX512(cpu)) {
|
||||
printf("cpufetch is measuring the AVX512 frequency...");
|
||||
compute_function = compute_avx512;
|
||||
num_spaces = 45;
|
||||
}
|
||||
else if(cpu->feat->AVX || cpu->feat->AVX2) {
|
||||
printf("cpufetch is measuring the AVX frequency...");
|
||||
compute_function = compute_avx;
|
||||
num_spaces = 42;
|
||||
}
|
||||
else {
|
||||
printf("cpufetch is measuring the frequency (no vector instructions)...");
|
||||
compute_function = compute_nov;
|
||||
num_spaces = 63;
|
||||
}
|
||||
|
||||
fflush(stdout);
|
||||
|
||||
pthread_t freq_t;
|
||||
if(pthread_create(&freq_t, NULL, measure_freq, freq_struct)) {
|
||||
fprintf(stderr, "Error creating thread\n");
|
||||
return -1;
|
||||
}
|
||||
|
||||
pthread_t* compute_th = malloc(sizeof(pthread_t) * cpu->topo->total_cores);
|
||||
cpu_set_t cpus;
|
||||
pthread_attr_t attr;
|
||||
if ((ret = pthread_attr_init(&attr)) != 0) {
|
||||
printErr("pthread_attr_init: %s", strerror(ret));
|
||||
return -1;
|
||||
}
|
||||
|
||||
for(int i=0; i < cpu->topo->total_cores; i++) {
|
||||
// We might have called bind_to_cpu previously, binding the threads
|
||||
// to a specific core, so now we must make sure we run the new thread
|
||||
// on the correct core.
|
||||
CPU_ZERO(&cpus);
|
||||
CPU_SET(i, &cpus);
|
||||
if ((ret = pthread_attr_setaffinity_np(&attr, sizeof(cpu_set_t), &cpus)) != 0) {
|
||||
printErr("pthread_attr_setaffinity_np: %s", strerror(ret));
|
||||
return -1;
|
||||
}
|
||||
|
||||
ret = pthread_create(&compute_th[i], &attr, compute_function, NULL);
|
||||
|
||||
if(ret != 0) {
|
||||
fprintf(stderr, "Error creating thread\n");
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
sleep_ms(500);
|
||||
freq_struct->measure = true;
|
||||
|
||||
for(int i=0; i < cpu->topo->total_cores; i++) {
|
||||
if(pthread_join(compute_th[i], NULL)) {
|
||||
fprintf(stderr, "Error joining thread\n");
|
||||
return -1;
|
||||
}
|
||||
freq_struct->end = true;
|
||||
}
|
||||
|
||||
if(pthread_join(freq_t, NULL)) {
|
||||
fprintf(stderr, "Error joining thread\n");
|
||||
return -1;
|
||||
}
|
||||
|
||||
printf("\r%*c", num_spaces, ' ');
|
||||
return max_freq_pp_vec[0];
|
||||
}
|
||||
@@ -1,13 +0,0 @@
|
||||
#ifndef __FREQ__
|
||||
#define __FREQ__
|
||||
|
||||
#include <stdint.h>
|
||||
#include "../../common/cpu.h"
|
||||
#include "../../common/global.h"
|
||||
|
||||
#define MEASURE_TIME_SECONDS 5
|
||||
#define LOOP_ITERS 100000000
|
||||
|
||||
int32_t measure_frequency(struct cpuInfo* cpu, int32_t *max_freq_pp_vec);
|
||||
|
||||
#endif
|
||||
@@ -1,57 +0,0 @@
|
||||
#include <stdio.h>
|
||||
#include <immintrin.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdbool.h>
|
||||
#include <sys/time.h>
|
||||
#include <time.h>
|
||||
#include <errno.h>
|
||||
#include <string.h>
|
||||
#include <pthread.h>
|
||||
#include <stdint.h>
|
||||
#include "freq.h"
|
||||
|
||||
void* compute_avx(void * pthread_arg) {
|
||||
UNUSED(pthread_arg);
|
||||
bool end = false;
|
||||
|
||||
struct timeval begin, now;
|
||||
|
||||
__m256 a[8];
|
||||
__m256 b[8];
|
||||
|
||||
for(int i=0; i < 8; i++) {
|
||||
a[i] = _mm256_set1_ps(1.5);
|
||||
b[i] = _mm256_set1_ps(1.2);
|
||||
}
|
||||
|
||||
gettimeofday(&begin, NULL);
|
||||
while(!end) {
|
||||
for(uint64_t i=0; i < LOOP_ITERS; i++) {
|
||||
a[0] = _mm256_add_ps(a[0], b[0]);
|
||||
a[1] = _mm256_add_ps(a[1], b[1]);
|
||||
a[2] = _mm256_add_ps(a[2], b[2]);
|
||||
a[3] = _mm256_add_ps(a[3], b[3]);
|
||||
a[4] = _mm256_add_ps(a[4], b[4]);
|
||||
a[5] = _mm256_add_ps(a[5], b[5]);
|
||||
a[6] = _mm256_add_ps(a[6], b[6]);
|
||||
a[7] = _mm256_add_ps(a[7], b[7]);
|
||||
}
|
||||
|
||||
gettimeofday(&now, NULL);
|
||||
double elapsed = (now.tv_sec - begin.tv_sec) + ((now.tv_usec - begin.tv_usec)/1000000.0);
|
||||
end = elapsed >= (double) MEASURE_TIME_SECONDS;
|
||||
}
|
||||
|
||||
FILE* fp = fopen("/dev/null", "w");
|
||||
if(fp == NULL) {
|
||||
printf("fopen: %s", strerror(errno));
|
||||
}
|
||||
else {
|
||||
for(int i=0; i < 8; i++)
|
||||
fprintf(fp, "%f", a[i][0]);
|
||||
fclose(fp);
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
@@ -1,6 +0,0 @@
|
||||
#ifndef __FREQ_AVX__
|
||||
#define __FREQ_AVX__
|
||||
|
||||
void* compute_avx(void * pthread_arg);
|
||||
|
||||
#endif
|
||||
@@ -1,57 +0,0 @@
|
||||
#include <stdio.h>
|
||||
#include <immintrin.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdbool.h>
|
||||
#include <sys/time.h>
|
||||
#include <time.h>
|
||||
#include <errno.h>
|
||||
#include <string.h>
|
||||
#include <pthread.h>
|
||||
#include <stdint.h>
|
||||
#include "freq.h"
|
||||
|
||||
void* compute_avx512(void * pthread_arg) {
|
||||
UNUSED(pthread_arg);
|
||||
bool end = false;
|
||||
|
||||
struct timeval begin, now;
|
||||
|
||||
__m512 a[8];
|
||||
__m512 b[8];
|
||||
|
||||
for(int i=0; i < 8; i++) {
|
||||
a[i] = _mm512_set1_ps(1.5);
|
||||
b[i] = _mm512_set1_ps(1.2);
|
||||
}
|
||||
|
||||
gettimeofday(&begin, NULL);
|
||||
while(!end) {
|
||||
for(uint64_t i=0; i < LOOP_ITERS; i++) {
|
||||
a[0] = _mm512_add_ps(a[0], b[0]);
|
||||
a[1] = _mm512_add_ps(a[1], b[1]);
|
||||
a[2] = _mm512_add_ps(a[2], b[2]);
|
||||
a[3] = _mm512_add_ps(a[3], b[3]);
|
||||
a[4] = _mm512_add_ps(a[4], b[4]);
|
||||
a[5] = _mm512_add_ps(a[5], b[5]);
|
||||
a[6] = _mm512_add_ps(a[6], b[6]);
|
||||
a[7] = _mm512_add_ps(a[7], b[7]);
|
||||
}
|
||||
|
||||
gettimeofday(&now, NULL);
|
||||
double elapsed = (now.tv_sec - begin.tv_sec) + ((now.tv_usec - begin.tv_usec)/1000000.0);
|
||||
end = elapsed >= (double) MEASURE_TIME_SECONDS;
|
||||
}
|
||||
|
||||
FILE* fp = fopen("/dev/null", "w");
|
||||
if(fp == NULL) {
|
||||
printf("fopen: %s", strerror(errno));
|
||||
}
|
||||
else {
|
||||
for(int i=0; i < 8; i++)
|
||||
fprintf(fp, "%f", a[i][0]);
|
||||
fclose(fp);
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
@@ -1,6 +0,0 @@
|
||||
#ifndef __FREQ_AVX512__
|
||||
#define __FREQ_AVX512__
|
||||
|
||||
void* compute_avx512(void * pthread_arg);
|
||||
|
||||
#endif
|
||||
@@ -1,45 +0,0 @@
|
||||
#include <stdio.h>
|
||||
#include <immintrin.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdbool.h>
|
||||
#include <sys/time.h>
|
||||
#include <time.h>
|
||||
#include <errno.h>
|
||||
#include <string.h>
|
||||
#include <pthread.h>
|
||||
#include <stdint.h>
|
||||
#include "freq.h"
|
||||
|
||||
void* compute_nov(void * pthread_arg) {
|
||||
UNUSED(pthread_arg);
|
||||
bool end = false;
|
||||
|
||||
struct timeval begin, now;
|
||||
|
||||
float a = 1.5;
|
||||
float b = 1.2;
|
||||
float c = 0.0;
|
||||
|
||||
gettimeofday(&begin, NULL);
|
||||
while(!end) {
|
||||
for(uint64_t i=0; i < LOOP_ITERS; i++) {
|
||||
c = a * b;
|
||||
}
|
||||
|
||||
gettimeofday(&now, NULL);
|
||||
double elapsed = (now.tv_sec - begin.tv_sec) + ((now.tv_usec - begin.tv_usec)/1000000.0);
|
||||
end = elapsed >= (double) MEASURE_TIME_SECONDS;
|
||||
}
|
||||
|
||||
FILE* fp = fopen("/dev/null", "w");
|
||||
if(fp == NULL) {
|
||||
printf("fopen: %s", strerror(errno));
|
||||
}
|
||||
else {
|
||||
fprintf(fp, "%f", c);
|
||||
fclose(fp);
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
@@ -1,6 +0,0 @@
|
||||
#ifndef __FREQ_NO_VECTOR__
|
||||
#define __FREQ_NO_VECTOR__
|
||||
|
||||
void* compute_nov(void * pthread_arg);
|
||||
|
||||
#endif
|
||||
341
src/x86/uarch.c
341
src/x86/uarch.c
@@ -47,12 +47,8 @@ typedef uint32_t MICROARCH;
|
||||
enum {
|
||||
UARCH_UNKNOWN,
|
||||
// INTEL //
|
||||
UARCH_I486,
|
||||
UARCH_P5,
|
||||
UARCH_P5_MMX,
|
||||
UARCH_P6_PRO,
|
||||
UARCH_P6_PENTIUM_II,
|
||||
UARCH_P6_PENTIUM_III,
|
||||
UARCH_P6,
|
||||
UARCH_DOTHAN,
|
||||
UARCH_YONAH,
|
||||
UARCH_MEROM,
|
||||
@@ -69,7 +65,6 @@ enum {
|
||||
UARCH_AIRMONT,
|
||||
UARCH_KABY_LAKE,
|
||||
UARCH_COMET_LAKE,
|
||||
UARCH_ROCKET_LAKE,
|
||||
UARCH_AMBER_LAKE,
|
||||
UARCH_WHISKEY_LAKE,
|
||||
UARCH_SKYLAKE,
|
||||
@@ -82,8 +77,8 @@ enum {
|
||||
UARCH_SUNNY_COVE,
|
||||
UARCH_GOLDMONT_PLUS,
|
||||
UARCH_TREMONT,
|
||||
UARCH_LAKEMONT,
|
||||
UARCH_COFFEE_LAKE,
|
||||
UARCH_WILLOW_COVE,
|
||||
UARCH_COFFE_LAKE,
|
||||
UARCH_ITANIUM,
|
||||
UARCH_KNIGHTS_FERRY,
|
||||
UARCH_KNIGHTS_CORNER,
|
||||
@@ -93,14 +88,9 @@ enum {
|
||||
UARCH_CEDAR_MILL,
|
||||
UARCH_ITANIUM2,
|
||||
UARCH_ICE_LAKE,
|
||||
UARCH_TIGER_LAKE,
|
||||
UARCH_ALDER_LAKE,
|
||||
UARCH_RAPTOR_LAKE,
|
||||
// AMD //
|
||||
UARCH_AM486,
|
||||
UARCH_AM5X86,
|
||||
UARCH_SSA5,
|
||||
UARCH_K5,
|
||||
UARCH_K6,
|
||||
UARCH_K7,
|
||||
UARCH_K8,
|
||||
@@ -116,10 +106,7 @@ enum {
|
||||
UARCH_ZEN,
|
||||
UARCH_ZEN_PLUS,
|
||||
UARCH_ZEN2,
|
||||
UARCH_ZEN3,
|
||||
UARCH_ZEN3_PLUS,
|
||||
UARCH_ZEN4,
|
||||
UARCH_ZEN4C
|
||||
UARCH_ZEN3
|
||||
};
|
||||
|
||||
struct uarch {
|
||||
@@ -131,11 +118,10 @@ struct uarch {
|
||||
#define UARCH_START if (false) {}
|
||||
#define CHECK_UARCH(arch, ef_, f_, em_, m_, s_, str, uarch, process) \
|
||||
else if (ef_ == ef && f_ == f && (em_ == NA || em_ == em) && (m_ == NA || m_ == m) && (s_ == NA || s_ == s)) fill_uarch(arch, str, uarch, process);
|
||||
#define UARCH_END else { printBugCheckRelease("Unknown microarchitecture detected: M=0x%X EM=0x%X F=0x%X EF=0x%X S=0x%X", m, em, f, ef, s); \
|
||||
fill_uarch(arch, STRING_UNKNOWN, UARCH_UNKNOWN, UNK); }
|
||||
#define UARCH_END else { printBug("Unknown microarchitecture detected: M=0x%.8X EM=0x%.8X F=0x%.8X EF=0x%.8X S=0x%.8X", m, em, f, ef, s); fill_uarch(arch, "Unknown", UARCH_UNKNOWN, 0); }
|
||||
|
||||
void fill_uarch(struct uarch* arch, char* str, MICROARCH u, uint32_t process) {
|
||||
arch->uarch_str = emalloc(sizeof(char) * (strlen(str)+1));
|
||||
arch->uarch_str = malloc(sizeof(char) * (strlen(str)+1));
|
||||
strcpy(arch->uarch_str, str);
|
||||
arch->uarch = u;
|
||||
arch->process= process;
|
||||
@@ -143,52 +129,36 @@ void fill_uarch(struct uarch* arch, char* str, MICROARCH u, uint32_t process) {
|
||||
|
||||
// Inspired in Todd Allen's decode_uarch_intel
|
||||
struct uarch* get_uarch_from_cpuid_intel(uint32_t ef, uint32_t f, uint32_t em, uint32_t m, int s) {
|
||||
struct uarch* arch = emalloc(sizeof(struct uarch));
|
||||
struct uarch* arch = malloc(sizeof(struct uarch));
|
||||
|
||||
// EF: Extended Family //
|
||||
// F: Family //
|
||||
// EM: Extended Model //
|
||||
// M: Model //
|
||||
// S: Stepping //
|
||||
// ------------------------------------------------------------------------------- //
|
||||
// ----------------------------------------------------------------------------- //
|
||||
// EF F EM M S //
|
||||
UARCH_START
|
||||
CHECK_UARCH(arch, 0, 4, 0, 0, NA, "i80486DX", UARCH_I486, UNK) // https://sandpile.org/x86/cpuid.htm#level_0000_0001h
|
||||
CHECK_UARCH(arch, 0, 4, 0, 1, NA, "i80486DX-50", UARCH_I486, UNK) // https://sandpile.org/x86/cpuid.htm#level_0000_0001h
|
||||
CHECK_UARCH(arch, 0, 4, 0, 2, NA, "i80486SX", UARCH_I486, UNK) // https://sandpile.org/x86/cpuid.htm#level_0000_0001h
|
||||
CHECK_UARCH(arch, 0, 4, 0, 3, NA, "i80486DX2", UARCH_I486, UNK) // https://sandpile.org/x86/cpuid.htm#level_0000_0001h
|
||||
CHECK_UARCH(arch, 0, 4, 0, 4, NA, "i80486SL", UARCH_I486, UNK) // https://sandpile.org/x86/cpuid.htm#level_0000_0001h
|
||||
CHECK_UARCH(arch, 0, 4, 0, 5, NA, "i80486SX2", UARCH_I486, UNK) // https://sandpile.org/x86/cpuid.htm#level_0000_0001h
|
||||
CHECK_UARCH(arch, 0, 4, 0, 7, NA, "i80486DX2WB", UARCH_I486, UNK) // https://sandpile.org/x86/cpuid.htm#level_0000_0001h
|
||||
CHECK_UARCH(arch, 0, 4, 0, 8, NA, "i80486DX4", UARCH_I486, UNK) // https://sandpile.org/x86/cpuid.htm#level_0000_0001h
|
||||
CHECK_UARCH(arch, 0, 4, 0, 9, NA, "i80486DX4WB", UARCH_I486, UNK) // https://sandpile.org/x86/cpuid.htm#level_0000_0001h
|
||||
CHECK_UARCH(arch, 0, 5, 0, 0, NA, "P5", UARCH_P5, 800)
|
||||
CHECK_UARCH(arch, 0, 5, 0, 1, NA, "P5", UARCH_P5, 800)
|
||||
CHECK_UARCH(arch, 0, 5, 0, 2, NA, "P54C", UARCH_P5, UNK) // https://sandpile.org/x86/cpuid.htm#level_0000_0001h
|
||||
CHECK_UARCH(arch, 0, 5, 0, 3, NA, "P24T (Overdrive)", UARCH_P5, 600) // https://sandpile.org/x86/cpuid.htm#level_0000_0001h
|
||||
CHECK_UARCH(arch, 0, 5, 0, 4, NA, "P55C (MMX)", UARCH_P5_MMX, 350) // https://www.cpu-world.com/CPUs/Pentium/TYPE-Pentium%20MMX.html
|
||||
CHECK_UARCH(arch, 0, 5, 0, 7, NA, "P54C", UARCH_P5, 350) // https://sandpile.org/x86/cpuid.htm#level_0000_0001h
|
||||
CHECK_UARCH(arch, 0, 5, 0, 8, NA, "Tillamook", UARCH_P5_MMX, 250) // http://instlatx64.atw.hu./
|
||||
CHECK_UARCH(arch, 0, 5, 0, 9, 0, "Lakemont", UARCH_LAKEMONT, 32)
|
||||
CHECK_UARCH(arch, 0, 5, 0, 9, NA, "P5 (MMX)", UARCH_P5_MMX, UNK)
|
||||
CHECK_UARCH(arch, 0, 5, 0, 10, 0, "Lakemont", UARCH_LAKEMONT, 32)
|
||||
CHECK_UARCH(arch, 0, 6, 0, 1, 1, "P6", UARCH_P6_PRO, UNK)
|
||||
CHECK_UARCH(arch, 0, 6, 0, 1, 2, "P6", UARCH_P6_PRO, UNK)
|
||||
CHECK_UARCH(arch, 0, 6, 0, 1, 6, "P6", UARCH_P6_PRO, 350)
|
||||
CHECK_UARCH(arch, 0, 6, 0, 1, 7, "P6", UARCH_P6_PRO, 350)
|
||||
CHECK_UARCH(arch, 0, 6, 0, 1, 9, "P6", UARCH_P6_PRO, 350)
|
||||
CHECK_UARCH(arch, 0, 6, 0, 0, NA, "P6 (Pentium II)", UARCH_P6_PENTIUM_II, UNK)
|
||||
CHECK_UARCH(arch, 0, 6, 0, 1, NA, "P6 (Pentium II)", UARCH_P6_PENTIUM_II, UNK) // process depends on core
|
||||
CHECK_UARCH(arch, 0, 6, 0, 2, NA, "P6 (Pentium II)", UARCH_P6_PENTIUM_II, UNK)
|
||||
CHECK_UARCH(arch, 0, 6, 0, 3, NA, "P6 (Klamath)", UARCH_P6_PENTIUM_II, 350) // http://instlatx64.atw.hu.
|
||||
CHECK_UARCH(arch, 0, 6, 0, 4, NA, "P6 (Pentium II)", UARCH_P6_PENTIUM_II, UNK)
|
||||
CHECK_UARCH(arch, 0, 6, 0, 5, NA, "P6 (Deschutes)", UARCH_P6_PENTIUM_II, 250) // http://instlatx64.atw.hu.
|
||||
CHECK_UARCH(arch, 0, 6, 0, 6, NA, "P6 (Dixon)", UARCH_P6_PENTIUM_II, UNK) // http://instlatx64.atw.hu.
|
||||
CHECK_UARCH(arch, 0, 6, 0, 7, NA, "P6 (Katmai)", UARCH_P6_PENTIUM_III, 250) // Core names from: https://en.wikichip.org/wiki/intel/cpuid. NOTE: Xeon core names are different! https://www.techpowerup.com/cpu-specs/?generation=Intel+Pentium+III+Xeon
|
||||
CHECK_UARCH(arch, 0, 6, 0, 8, NA, "P6 (Coppermine)", UARCH_P6_PENTIUM_III, 180) // Also: https://en.wikipedia.org/wiki/Pentium_III
|
||||
CHECK_UARCH(arch, 0, 6, 0, 9, NA, "P6 (Pentium M)", UARCH_P6_PENTIUM_III, 130)
|
||||
CHECK_UARCH(arch, 0, 6, 0, 10, NA, "P6 (Coppermine T)", UARCH_P6_PENTIUM_III, 180)
|
||||
CHECK_UARCH(arch, 0, 6, 0, 11, NA, "P6 (Tualatin)", UARCH_P6_PENTIUM_III, 130)
|
||||
CHECK_UARCH(arch, 0, 5, 0, 2, NA, "P5", UARCH_P5, UNK)
|
||||
CHECK_UARCH(arch, 0, 5, 0, 3, NA, "P5", UARCH_P5, 600)
|
||||
CHECK_UARCH(arch, 0, 5, 0, 4, NA, "P5 MMX", UARCH_P5, UNK)
|
||||
CHECK_UARCH(arch, 0, 5, 0, 7, NA, "P5 MMX", UARCH_P5, UNK)
|
||||
CHECK_UARCH(arch, 0, 5, 0, 8, NA, "P5 MMX", UARCH_P5, 250)
|
||||
CHECK_UARCH(arch, 0, 5, 0, 9, NA, "P5 MMX", UARCH_P5, UNK)
|
||||
CHECK_UARCH(arch, 0, 6, 0, 0, NA, "P6 Pentium II", UARCH_P6, UNK)
|
||||
CHECK_UARCH(arch, 0, 6, 0, 1, NA, "P6 Pentium II", UARCH_P6, UNK) // process depends on core
|
||||
CHECK_UARCH(arch, 0, 6, 0, 2, NA, "P6 Pentium II", UARCH_P6, UNK)
|
||||
CHECK_UARCH(arch, 0, 6, 0, 3, NA, "P6 Pentium II", UARCH_P6, 350)
|
||||
CHECK_UARCH(arch, 0, 6, 0, 4, NA, "P6 Pentium II", UARCH_P6, UNK)
|
||||
CHECK_UARCH(arch, 0, 6, 0, 5, NA, "P6 Pentium II", UARCH_P6, 250)
|
||||
CHECK_UARCH(arch, 0, 6, 0, 6, NA, "P6 Pentium II", UARCH_P6, UNK)
|
||||
CHECK_UARCH(arch, 0, 6, 0, 7, NA, "P6 Pentium III", UARCH_P6, 250)
|
||||
CHECK_UARCH(arch, 0, 6, 0, 8, NA, "P6 Pentium III", UARCH_P6, 180)
|
||||
CHECK_UARCH(arch, 0, 6, 0, 9, NA, "P6 Pentium M", UARCH_P6, 130)
|
||||
CHECK_UARCH(arch, 0, 6, 0, 10, NA, "P6 Pentium III", UARCH_P6, 180)
|
||||
CHECK_UARCH(arch, 0, 6, 0, 11, NA, "P6 Pentium III", UARCH_P6, 130)
|
||||
CHECK_UARCH(arch, 0, 6, 0, 13, NA, "Dothan", UARCH_DOTHAN, UNK) // process depends on core
|
||||
CHECK_UARCH(arch, 0, 6, 0, 14, NA, "Yonah", UARCH_YONAH, 65)
|
||||
CHECK_UARCH(arch, 0, 6, 0, 15, NA, "Merom", UARCH_MEROM, 65)
|
||||
@@ -247,29 +217,22 @@ struct uarch* get_uarch_from_cpuid_intel(uint32_t ef, uint32_t f, uint32_t em, u
|
||||
CHECK_UARCH(arch, 0, 6, 8, 5, NA, "Knights Mill", UARCH_KNIGHTS_MILL, 14) // no spec update; only MSR_CPUID_table* so far
|
||||
CHECK_UARCH(arch, 0, 6, 8, 6, NA, "Tremont", UARCH_TREMONT, 10) // LX*
|
||||
CHECK_UARCH(arch, 0, 6, 8, 10, NA, "Tremont", UARCH_TREMONT, 10) // no spec update; only geekbench.com example
|
||||
CHECK_UARCH(arch, 0, 6, 8, 12, NA, "Tiger Lake", UARCH_TIGER_LAKE, 10) // instlatx64
|
||||
CHECK_UARCH(arch, 0, 6, 8, 13, NA, "Tiger Lake", UARCH_TIGER_LAKE, 10) // instlatx64
|
||||
// CHECK_UARCH(arch, 0, 6, 8, 14, 9, ...) It is not possible to determine uarch only from CPUID dump (can be Kaby Lake or Amber Lake)
|
||||
// CHECK_UARCH(arch, 0, 6, 8, 14, 10, ...) It is not possible to determine uarch only from CPUID dump (can be Kaby Lake R or Coffee Lake U)
|
||||
CHECK_UARCH(arch, 0, 6, 8, 12, NA, "Willow Cove", UARCH_WILLOW_COVE, 10) // found only on en.wikichip.org
|
||||
CHECK_UARCH(arch, 0, 6, 8, 13, NA, "Willow Cove", UARCH_WILLOW_COVE, 10) // LX*
|
||||
CHECK_UARCH(arch, 0, 6, 8, 14, 9, "Amber Lake", UARCH_AMBER_LAKE, 14) // wikichip
|
||||
CHECK_UARCH(arch, 0, 6, 8, 14, 10, "Kaby Lake", UARCH_KABY_LAKE, 14) // wikichip
|
||||
CHECK_UARCH(arch, 0, 6, 8, 14, 11, "Whiskey Lake", UARCH_WHISKEY_LAKE, 14) // wikichip
|
||||
CHECK_UARCH(arch, 0, 6, 8, 14, 12, "Comet Lake", UARCH_COMET_LAKE, 14) // wikichip
|
||||
CHECK_UARCH(arch, 0, 6, 9, 6, NA, "Tremont", UARCH_TREMONT, 10) // LX*
|
||||
CHECK_UARCH(arch, 0, 6, 9, 7, NA, "Alder Lake", UARCH_ALDER_LAKE, 10) // instlatx64 (Alder Lake-S)
|
||||
CHECK_UARCH(arch, 0, 6, 9, 10, NA, "Alder Lake", UARCH_ALDER_LAKE, 10) // instlatx64 (Alder Lake-P)
|
||||
CHECK_UARCH(arch, 0, 6, 9, 12, NA, "Tremont", UARCH_TREMONT, 10) // LX*
|
||||
CHECK_UARCH(arch, 0, 6, 9, 13, NA, "Sunny Cove", UARCH_SUNNY_COVE, 10) // LX*
|
||||
CHECK_UARCH(arch, 0, 6, 9, 14, 9, "Kaby Lake", UARCH_KABY_LAKE, 14)
|
||||
CHECK_UARCH(arch, 0, 6, 9, 14, 10, "Coffee Lake", UARCH_COFFEE_LAKE, 14)
|
||||
CHECK_UARCH(arch, 0, 6, 9, 14, 11, "Coffee Lake", UARCH_COFFEE_LAKE, 14)
|
||||
CHECK_UARCH(arch, 0, 6, 9, 14, 12, "Coffee Lake", UARCH_COFFEE_LAKE, 14)
|
||||
CHECK_UARCH(arch, 0, 6, 9, 14, 13, "Coffee Lake", UARCH_COFFEE_LAKE, 14)
|
||||
CHECK_UARCH(arch, 0, 6, 9, 14, 10, "Coffee Lake", UARCH_COFFE_LAKE, 14)
|
||||
CHECK_UARCH(arch, 0, 6, 9, 14, 11, "Coffee Lake", UARCH_COFFE_LAKE, 14)
|
||||
CHECK_UARCH(arch, 0, 6, 9, 14, 12, "Coffee Lake", UARCH_COFFE_LAKE, 14)
|
||||
CHECK_UARCH(arch, 0, 6, 9, 14, 13, "Coffee Lake", UARCH_COFFE_LAKE, 14)
|
||||
CHECK_UARCH(arch, 0, 6, 10, 5, NA, "Comet Lake", UARCH_COMET_LAKE, 14) // wikichip
|
||||
CHECK_UARCH(arch, 0, 6, 10, 6, NA, "Comet Lake", UARCH_COMET_LAKE, 14) // instlatx64.atw.hu (i7-10710U)
|
||||
CHECK_UARCH(arch, 0, 6, 10, 7, NA, "Rocket Lake", UARCH_ROCKET_LAKE, 14) // instlatx64.atw.hu (i7-11700K)
|
||||
CHECK_UARCH(arch, 0, 6, 11, 7, NA, "Raptor Lake", UARCH_RAPTOR_LAKE, 10) // instlatx64.atw.hu (i5-13600K)
|
||||
CHECK_UARCH(arch, 0, 6, 11, 10, NA, "Raptor Lake", UARCH_RAPTOR_LAKE, 10) // instlatx64.atw.hu (i7-1370P)
|
||||
CHECK_UARCH(arch, 0, 6, 11, 14, NA, "Alder Lake", UARCH_ALDER_LAKE, 10) // instlatx64.atw.hu (Alder Lake-N)
|
||||
CHECK_UARCH(arch, 0, 6, 11, 15, NA, "Raptor Lake", UARCH_RAPTOR_LAKE, 10) // instlatx64.atw.hu (i5-13500)
|
||||
CHECK_UARCH(arch, 0, 11, 0, 0, NA, "Knights Ferry", UARCH_KNIGHTS_FERRY, 45) // found only on en.wikichip.org
|
||||
CHECK_UARCH(arch, 0, 11, 0, 1, NA, "Knights Corner", UARCH_KNIGHTS_CORNER, 22)
|
||||
CHECK_UARCH(arch, 0, 15, 0, 0, NA, "Willamette", UARCH_WILLAMETTE, 180)
|
||||
@@ -282,12 +245,13 @@ struct uarch* get_uarch_from_cpuid_intel(uint32_t ef, uint32_t f, uint32_t em, u
|
||||
CHECK_UARCH(arch, 1, 15, 0, 1, NA, "Itanium2", UARCH_ITANIUM2, 130)
|
||||
CHECK_UARCH(arch, 1, 15, 0, 2, NA, "Itanium2", UARCH_ITANIUM2, 130)
|
||||
UARCH_END
|
||||
|
||||
return arch;
|
||||
}
|
||||
|
||||
// Inspired in Todd Allen's decode_uarch_amd
|
||||
// iNApired in Todd Allen's decode_uarch_amd
|
||||
struct uarch* get_uarch_from_cpuid_amd(uint32_t ef, uint32_t f, uint32_t em, uint32_t m, int s) {
|
||||
struct uarch* arch = emalloc(sizeof(struct uarch));
|
||||
struct uarch* arch = malloc(sizeof(struct uarch));
|
||||
|
||||
// EF: Extended Family //
|
||||
// F: Family //
|
||||
@@ -297,19 +261,13 @@ struct uarch* get_uarch_from_cpuid_amd(uint32_t ef, uint32_t f, uint32_t em, uin
|
||||
// ----------------------------------------------------------------------------- //
|
||||
// EF F EM M S //
|
||||
UARCH_START
|
||||
CHECK_UARCH(arch, 0, 4, 0, 3, NA, "Am486DX2", UARCH_AM486, UNK) // https://sandpile.org/x86/cpuid.htm#level_0000_0001h
|
||||
CHECK_UARCH(arch, 0, 4, 0, 7, NA, "Am486DX2WB", UARCH_AM486, UNK) // https://sandpile.org/x86/cpuid.htm#level_0000_0001h
|
||||
CHECK_UARCH(arch, 0, 4, 0, 8, NA, "Am486DX4", UARCH_AM486, UNK) // https://sandpile.org/x86/cpuid.htm#level_0000_0001h
|
||||
CHECK_UARCH(arch, 0, 4, 0, 9, NA, "Am486DX4WB", UARCH_AM486, UNK) // https://sandpile.org/x86/cpuid.htm#level_0000_0001h
|
||||
CHECK_UARCH(arch, 0, 4, 0, 14, NA, "Am5x86", UARCH_AM5X86, 350) // https://sandpile.org/x86/cpuid.htm#level_0000_0001h
|
||||
CHECK_UARCH(arch, 0, 4, 0, 15, NA, "Am5x86WB", UARCH_AM5X86, 350) // https://sandpile.org/x86/cpuid.htm#level_0000_0001h
|
||||
CHECK_UARCH(arch, 0, 5, 0, 0, NA, "SSA5 (K5)", UARCH_SSA5, 350) // https://sandpile.org/x86/cpuid.htm#level_0000_0001h
|
||||
CHECK_UARCH(arch, 0, 5, 0, 1, NA, "K5", UARCH_K5, 350) // https://sandpile.org/x86/cpuid.htm#level_0000_0001h
|
||||
CHECK_UARCH(arch, 0, 5, 0, 2, NA, "K5", UARCH_K5, 350) // https://sandpile.org/x86/cpuid.htm#level_0000_0001h
|
||||
CHECK_UARCH(arch, 0, 5, 0, 3, NA, "K5", UARCH_K5, 350) // https://sandpile.org/x86/cpuid.htm#level_0000_0001h
|
||||
CHECK_UARCH(arch, 0, 4, 0, 3, NA, "Am486", UARCH_AM486, UNK)
|
||||
CHECK_UARCH(arch, 0, 4, 0, 7, NA, "Am486", UARCH_AM486, UNK)
|
||||
CHECK_UARCH(arch, 0, 4, 0, 8, NA, "Am486", UARCH_AM486, UNK)
|
||||
CHECK_UARCH(arch, 0, 4, 0, 9, NA, "Am486", UARCH_AM486, UNK)
|
||||
CHECK_UARCH(arch, 0, 4, NA, NA, NA, "Am5x86", UARCH_AM5X86, UNK)
|
||||
CHECK_UARCH(arch, 0, 5, 0, 6, NA, "K6", UARCH_K6, 300)
|
||||
CHECK_UARCH(arch, 0, 5, 0, 7, NA, "K6", UARCH_K6, 250) // *p from sandpile.org
|
||||
CHECK_UARCH(arch, 0, 5, 0, 10, NA, "K7", UARCH_K7, 130) // Geode NX
|
||||
CHECK_UARCH(arch, 0, 5, 0, 13, NA, "K6", UARCH_K6, 80) // *p from sandpile.org
|
||||
CHECK_UARCH(arch, 0, 5, NA, NA, NA, "K6", UARCH_K6, UNK)
|
||||
CHECK_UARCH(arch, 0, 6, 0, 1, NA, "K7", UARCH_K7, 250)
|
||||
@@ -365,7 +323,7 @@ struct uarch* get_uarch_from_cpuid_amd(uint32_t ef, uint32_t f, uint32_t em, uin
|
||||
CHECK_UARCH(arch, 2, 15, NA, NA, NA, "Puma 2008", UARCH_PUMA_2008, 65)
|
||||
CHECK_UARCH(arch, 3, 15, NA, NA, NA, "K10", UARCH_K10, 32)
|
||||
CHECK_UARCH(arch, 5, 15, NA, NA, NA, "Bobcat", UARCH_BOBCAT, 40)
|
||||
CHECK_UARCH(arch, 6, 15, 0, 0, NA, "Bulldozer", UARCH_BULLDOZER, 32) // instlatx64 engr sample
|
||||
CHECK_UARCH(arch, 6, 15, 0, 0, NA, "Bulldozer", UARCH_BULLDOZER, 32) // iNAtlatx64 engr sample
|
||||
CHECK_UARCH(arch, 6, 15, 0, 1, NA, "Bulldozer", UARCH_BULLDOZER, 32)
|
||||
CHECK_UARCH(arch, 6, 15, 0, 2, NA, "Piledriver", UARCH_PILEDRIVER, 32)
|
||||
CHECK_UARCH(arch, 6, 15, 1, 0, NA, "Piledriver", UARCH_PILEDRIVER, 32)
|
||||
@@ -373,189 +331,34 @@ struct uarch* get_uarch_from_cpuid_amd(uint32_t ef, uint32_t f, uint32_t em, uin
|
||||
CHECK_UARCH(arch, 6, 15, 3, 0, NA, "Steamroller", UARCH_STEAMROLLER, 28)
|
||||
CHECK_UARCH(arch, 6, 15, 3, 8, NA, "Steamroller", UARCH_STEAMROLLER, 28)
|
||||
CHECK_UARCH(arch, 6, 15, 4, 0, NA, "Steamroller", UARCH_STEAMROLLER, 28) // Software Optimization Guide (15h) says it has the same iNAt latencies as (6,15),(3,x).
|
||||
CHECK_UARCH(arch, 6, 15, 6, 0, NA, "Excavator", UARCH_EXCAVATOR, 28) // undocumented, but instlatx64 samples
|
||||
CHECK_UARCH(arch, 6, 15, 6, 0, NA, "Excavator", UARCH_EXCAVATOR, 28) // undocumented, but iNAtlatx64 samples
|
||||
CHECK_UARCH(arch, 6, 15, 6, 5, NA, "Excavator", UARCH_EXCAVATOR, 28) // undocumented, but sample from Alexandros Couloumbis
|
||||
CHECK_UARCH(arch, 6, 15, 7, 0, NA, "Excavator", UARCH_EXCAVATOR, 28)
|
||||
CHECK_UARCH(arch, 7, 15, 0, 0, NA, "Jaguar", UARCH_JAGUAR, 28)
|
||||
CHECK_UARCH(arch, 7, 15, 1, NA, NA, "Jaguar", UARCH_JAGUAR, 14) // instlatx64 (PS4) Normal PS4 is 28nm, Slim and Pro are 16nm
|
||||
CHECK_UARCH(arch, 7, 15, 2, 6, NA, "Jaguar", UARCH_JAGUAR, 28) // AMD Cato (Xbox One?)
|
||||
CHECK_UARCH(arch, 7, 15, 3, 0, NA, "Puma 2014", UARCH_PUMA_2014, 28)
|
||||
CHECK_UARCH(arch, 8, 15, 0, 0, NA, "Zen", UARCH_ZEN, 14) // instlatx64 engr sample
|
||||
CHECK_UARCH(arch, 8, 15, 0, 0, NA, "Zen", UARCH_ZEN, 14) // iNAtlatx64 engr sample
|
||||
CHECK_UARCH(arch, 8, 15, 0, 1, NA, "Zen", UARCH_ZEN, 14)
|
||||
CHECK_UARCH(arch, 8, 15, 0, 8, NA, "Zen+", UARCH_ZEN_PLUS, 12)
|
||||
CHECK_UARCH(arch, 8, 15, 1, 1, NA, "Zen", UARCH_ZEN, 14) // found only on en.wikichip.org & instlatx64 examples
|
||||
CHECK_UARCH(arch, 8, 15, 1, 1, NA, "Zen", UARCH_ZEN, 14) // found only on en.wikichip.org & iNAtlatx64 examples
|
||||
CHECK_UARCH(arch, 8, 15, 1, 8, NA, "Zen+", UARCH_ZEN_PLUS, 12) // found only on en.wikichip.org
|
||||
CHECK_UARCH(arch, 8, 15, 2, 0, NA, "Zen", UARCH_ZEN, 14) // Dali, found on instlatx64 and en.wikichip.org
|
||||
CHECK_UARCH(arch, 8, 15, 3, 1, NA, "Zen 2", UARCH_ZEN2, 7) // found only on en.wikichip.org
|
||||
CHECK_UARCH(arch, 8, 15, 4, 7, NA, "Zen 2", UARCH_ZEN2, 7) // instlatx64 example (AMD 4700S)
|
||||
CHECK_UARCH(arch, 8, 15, 5, 0, NA, "Zen", UARCH_ZEN, 14) // instlatx64 example (Subor Z+)
|
||||
CHECK_UARCH(arch, 8, 15, 6, 0, NA, "Zen 2", UARCH_ZEN2, 7) // undocumented, geekbench.com example
|
||||
CHECK_UARCH(arch, 8, 15, 6, 8, NA, "Zen 2", UARCH_ZEN2, 7) // found on instlatx64
|
||||
CHECK_UARCH(arch, 8, 15, 7, 1, NA, "Zen 2", UARCH_ZEN2, 7) // samples from Steven Noonan and instlatx64
|
||||
CHECK_UARCH(arch, 8, 15, 8, 4, NA, "Zen 2", UARCH_ZEN2, 7) // instlatx64 (Xbox Series X?)
|
||||
CHECK_UARCH(arch, 8, 15, 9, 0, 2, "Zen 2", UARCH_ZEN2, 7) // Steam Deck (instlatx64)
|
||||
CHECK_UARCH(arch, 8, 15, 10, 0, NA, "Zen 2", UARCH_ZEN2, 6) // instlatx64
|
||||
CHECK_UARCH(arch, 10, 15, 0, 1, NA, "Zen 3", UARCH_ZEN3, 7) // instlatx64
|
||||
CHECK_UARCH(arch, 10, 15, 0, 8, NA, "Zen 3", UARCH_ZEN3, 7) // instlatx64
|
||||
CHECK_UARCH(arch, 10, 15, 1, 1, NA, "Zen 4", UARCH_ZEN4, 5) // instlatx64
|
||||
CHECK_UARCH(arch, 10, 15, 1, 8, NA, "Zen 4", UARCH_ZEN4, 5) // instlatx64
|
||||
CHECK_UARCH(arch, 10, 15, 2, 1, NA, "Zen 3", UARCH_ZEN3, 7) // instlatx64
|
||||
CHECK_UARCH(arch, 10, 15, 3, NA, NA, "Zen 3", UARCH_ZEN3, 7) // instlatx64
|
||||
CHECK_UARCH(arch, 10, 15, 4, 4, NA, "Zen 3+", UARCH_ZEN3_PLUS, 6) // instlatx64 (they say it is Zen3...)
|
||||
CHECK_UARCH(arch, 10, 15, 5, 0, NA, "Zen 3", UARCH_ZEN3, 7) // instlatx64
|
||||
CHECK_UARCH(arch, 10, 15, 6, 1, 2, "Zen 4", UARCH_ZEN4, 5) // instlatx64
|
||||
CHECK_UARCH(arch, 10, 15, 7, 4, 1, "Zen 4", UARCH_ZEN4, 4) // instlatx64
|
||||
CHECK_UARCH(arch, 10, 15, 7, 5, 2, "Zen 4", UARCH_ZEN4, 4) // instlatx64
|
||||
CHECK_UARCH(arch, 10, 15, 7, 8, 0, "Zen 4", UARCH_ZEN4, 4) // instlatx64
|
||||
CHECK_UARCH(arch, 10, 15, 8, NA, NA, "Zen 4", UARCH_ZEN4, 5) // instlatx64 (AMD MI300C)
|
||||
CHECK_UARCH(arch, 10, 15, 9, NA, NA, "Zen 4", UARCH_ZEN4, 5) // instlatx64 (AMD MI300A)
|
||||
CHECK_UARCH(arch, 10, 15, 10, NA, NA, "Zen 4c", UARCH_ZEN4C, 5) // instlatx64
|
||||
CHECK_UARCH(arch, 8, 15, 7, 1, NA, "Zen 2", UARCH_ZEN2, 7) // undocumented, but samples from Steven Noonan
|
||||
CHECK_UARCH(arch, 10, 15, NA, NA, NA, "Zen 3", UARCH_ZEN3, 7) // undocumented, LX*
|
||||
UARCH_END
|
||||
|
||||
return arch;
|
||||
}
|
||||
|
||||
struct uarch* get_uarch_from_cpuid_hygon(uint32_t ef, uint32_t f, uint32_t em, uint32_t m, int s) {
|
||||
struct uarch* arch = emalloc(sizeof(struct uarch));
|
||||
|
||||
// EF: Extended Family //
|
||||
// F: Family //
|
||||
// EM: Extended Model //
|
||||
// M: Model //
|
||||
// S: Stepping //
|
||||
// ----------------------------------------------------------------------------- //
|
||||
// EF F EM M S //
|
||||
UARCH_START
|
||||
// https://www.phoronix.com/news/Hygon-Dhyana-AMD-China-CPUs
|
||||
CHECK_UARCH(arch, 9, 15, 0, 1, NA, "Zen", UARCH_ZEN, UNK) // https://github.com/Dr-Noob/cpufetch/issues/244
|
||||
// CHECK_UARCH(arch, 9, 15, 0, 2, NA, "???", ?????????, UNK) // http://instlatx64.atw.hu/
|
||||
UARCH_END
|
||||
|
||||
return arch;
|
||||
}
|
||||
|
||||
struct uarch* get_uarch_from_cpuid(struct cpuInfo* cpu, uint32_t dump, uint32_t ef, uint32_t f, uint32_t em, uint32_t m, int s) {
|
||||
if(cpu->cpu_vendor == CPU_VENDOR_INTEL) {
|
||||
struct uarch* arch = emalloc(sizeof(struct uarch));
|
||||
if(dump == 0x000806E9) {
|
||||
if (cpu->cpu_name == NULL) {
|
||||
printErr("Unable to find uarch without CPU name");
|
||||
fill_uarch(arch, STRING_UNKNOWN, UARCH_UNKNOWN, UNK);
|
||||
return arch;
|
||||
}
|
||||
|
||||
// It is not possible to determine uarch only from CPUID dump (can be Kaby Lake or Amber Lake)
|
||||
// See issue https://github.com/Dr-Noob/cpufetch/issues/122
|
||||
if(strstr(cpu->cpu_name, "Y") != NULL) {
|
||||
fill_uarch(arch, "Amber Lake", UARCH_AMBER_LAKE, 14);
|
||||
}
|
||||
else {
|
||||
fill_uarch(arch, "Kaby Lake", UARCH_KABY_LAKE, 14);
|
||||
}
|
||||
|
||||
return arch;
|
||||
}
|
||||
else if (dump == 0x000806EA) {
|
||||
if (cpu->cpu_name == NULL) {
|
||||
printErr("Unable to find uarch without CPU name");
|
||||
fill_uarch(arch, STRING_UNKNOWN, UARCH_UNKNOWN, UNK);
|
||||
return arch;
|
||||
}
|
||||
|
||||
// It is not possible to determine uarch only from CPUID dump (can be Kaby Lake R or Coffee Lake U)
|
||||
// See issue https://github.com/Dr-Noob/cpufetch/issues/149
|
||||
if(strstr(cpu->cpu_name, "i5-8250U") != NULL ||
|
||||
strstr(cpu->cpu_name, "i5-8350U") != NULL ||
|
||||
strstr(cpu->cpu_name, "i7-8550U") != NULL ||
|
||||
strstr(cpu->cpu_name, "i7-8650U") != NULL) {
|
||||
fill_uarch(arch, "Kaby Lake", UARCH_KABY_LAKE, 14);
|
||||
}
|
||||
else {
|
||||
fill_uarch(arch, "Coffee Lake", UARCH_COFFEE_LAKE, 14);
|
||||
}
|
||||
|
||||
return arch;
|
||||
}
|
||||
struct uarch* get_uarch_from_cpuid(struct cpuInfo* cpu, uint32_t ef, uint32_t f, uint32_t em, uint32_t m, int s) {
|
||||
if(cpu->cpu_vendor == CPU_VENDOR_INTEL)
|
||||
return get_uarch_from_cpuid_intel(ef, f, em, m, s);
|
||||
}
|
||||
else if(cpu->cpu_vendor == CPU_VENDOR_AMD) {
|
||||
else
|
||||
return get_uarch_from_cpuid_amd(ef, f, em, m, s);
|
||||
}
|
||||
else if(cpu->cpu_vendor == CPU_VENDOR_HYGON) {
|
||||
return get_uarch_from_cpuid_hygon(ef, f, em, m, s);
|
||||
}
|
||||
else {
|
||||
printBug("Invalid CPU vendor: %d", cpu->cpu_vendor);
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
|
||||
// If we cannot get the CPU name from CPUID, try to infer it from uarch
|
||||
char* infer_cpu_name_from_uarch(struct uarch* arch) {
|
||||
char* cpu_name = NULL;
|
||||
if (arch == NULL) {
|
||||
printErr("infer_cpu_name_from_uarch: Unable to find CPU name");
|
||||
cpu_name = ecalloc(strlen(STRING_UNKNOWN) + 1, sizeof(char));
|
||||
strcpy(cpu_name, STRING_UNKNOWN);
|
||||
return cpu_name;
|
||||
}
|
||||
|
||||
char *str = NULL;
|
||||
|
||||
switch (arch->uarch) {
|
||||
// Intel
|
||||
case UARCH_I486:
|
||||
str = "Intel 486";
|
||||
break;
|
||||
case UARCH_P5:
|
||||
str = "Intel Pentium";
|
||||
break;
|
||||
case UARCH_P5_MMX:
|
||||
str = "Intel Pentium MMX";
|
||||
break;
|
||||
case UARCH_P6_PRO:
|
||||
str = "Intel Pentium Pro";
|
||||
break;
|
||||
case UARCH_P6_PENTIUM_II:
|
||||
str = "Intel Pentium II";
|
||||
break;
|
||||
case UARCH_P6_PENTIUM_III:
|
||||
str = "Intel Pentium III";
|
||||
break;
|
||||
|
||||
// AMD
|
||||
case UARCH_AM486:
|
||||
str = "AMD 486";
|
||||
break;
|
||||
case UARCH_AM5X86:
|
||||
str = "AMD 5x86";
|
||||
break;
|
||||
case UARCH_SSA5:
|
||||
str = "AMD 5k86";
|
||||
break;
|
||||
|
||||
default:
|
||||
printErr("Unable to find name from uarch: %d", arch->uarch);
|
||||
break;
|
||||
}
|
||||
|
||||
if (str == NULL) {
|
||||
cpu_name = ecalloc(strlen(STRING_UNKNOWN) + 1, sizeof(char));
|
||||
strcpy(cpu_name, STRING_UNKNOWN);
|
||||
}
|
||||
else {
|
||||
cpu_name = ecalloc(strlen(str) + 1, sizeof(char));
|
||||
strcpy(cpu_name, str);
|
||||
}
|
||||
|
||||
return cpu_name;
|
||||
}
|
||||
|
||||
bool vpus_are_AVX512(struct cpuInfo* cpu) {
|
||||
return cpu->arch->uarch != UARCH_ICE_LAKE &&
|
||||
cpu->arch->uarch != UARCH_TIGER_LAKE &&
|
||||
cpu->arch->uarch != UARCH_ZEN4 &&
|
||||
cpu->arch->uarch != UARCH_ZEN4C;
|
||||
return cpu->arch->uarch != UARCH_ICE_LAKE;
|
||||
}
|
||||
|
||||
bool is_knights_landing(struct cpuInfo* cpu) {
|
||||
@@ -564,7 +367,6 @@ bool is_knights_landing(struct cpuInfo* cpu) {
|
||||
|
||||
int get_number_of_vpus(struct cpuInfo* cpu) {
|
||||
switch(cpu->arch->uarch) {
|
||||
// Intel
|
||||
case UARCH_HASWELL:
|
||||
case UARCH_BROADWELL:
|
||||
|
||||
@@ -572,62 +374,37 @@ int get_number_of_vpus(struct cpuInfo* cpu) {
|
||||
case UARCH_CASCADE_LAKE:
|
||||
case UARCH_KABY_LAKE:
|
||||
case UARCH_COMET_LAKE:
|
||||
case UARCH_ROCKET_LAKE:
|
||||
case UARCH_AMBER_LAKE:
|
||||
case UARCH_WHISKEY_LAKE:
|
||||
case UARCH_COFFEE_LAKE:
|
||||
case UARCH_COFFE_LAKE:
|
||||
case UARCH_PALM_COVE:
|
||||
|
||||
case UARCH_KNIGHTS_LANDING:
|
||||
case UARCH_KNIGHTS_MILL:
|
||||
|
||||
case UARCH_ICE_LAKE:
|
||||
case UARCH_TIGER_LAKE:
|
||||
case UARCH_ALDER_LAKE:
|
||||
case UARCH_RAPTOR_LAKE:
|
||||
|
||||
// AMD
|
||||
// Right now is just a guess!
|
||||
case UARCH_ZEN2:
|
||||
case UARCH_ZEN3:
|
||||
case UARCH_ZEN3_PLUS:
|
||||
case UARCH_ZEN4:
|
||||
case UARCH_ZEN4C:
|
||||
return 2;
|
||||
default:
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
|
||||
bool choose_new_intel_logo_uarch(struct cpuInfo* cpu) {
|
||||
switch(cpu->arch->uarch) {
|
||||
case UARCH_ALDER_LAKE:
|
||||
case UARCH_ROCKET_LAKE:
|
||||
case UARCH_TIGER_LAKE:
|
||||
case UARCH_RAPTOR_LAKE:
|
||||
return true;
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
char* get_str_uarch(struct cpuInfo* cpu) {
|
||||
return cpu->arch->uarch_str;
|
||||
}
|
||||
|
||||
char* get_str_process(struct cpuInfo* cpu) {
|
||||
char* str = emalloc(sizeof(char) * (strlen(STRING_UNKNOWN)+1));
|
||||
int32_t process = cpu->arch->process;
|
||||
char* str = malloc(sizeof(char) * (4+2+1));
|
||||
uint32_t process = cpu->arch->process;
|
||||
|
||||
if(process == UNK) {
|
||||
snprintf(str, strlen(STRING_UNKNOWN)+1, STRING_UNKNOWN);
|
||||
}
|
||||
else if(process > 0){
|
||||
if(process > 100)
|
||||
sprintf(str, "%.2fum", (double)process/100);
|
||||
else
|
||||
sprintf(str, "%dnm", process);
|
||||
}
|
||||
else {
|
||||
snprintf(str, strlen(STRING_UNKNOWN)+1, STRING_UNKNOWN);
|
||||
printBug("Found invalid process: '%d'", process);
|
||||
}
|
||||
|
||||
return str;
|
||||
}
|
||||
|
||||
@@ -7,12 +7,10 @@
|
||||
|
||||
struct uarch;
|
||||
|
||||
struct uarch* get_uarch_from_cpuid(struct cpuInfo* cpu, uint32_t dump, uint32_t ef, uint32_t f, uint32_t em, uint32_t m, int s);
|
||||
char* infer_cpu_name_from_uarch(struct uarch* arch);
|
||||
struct uarch* get_uarch_from_cpuid(struct cpuInfo* cpu, uint32_t ef, uint32_t f, uint32_t em, uint32_t m, int s);
|
||||
bool vpus_are_AVX512(struct cpuInfo* cpu);
|
||||
bool is_knights_landing(struct cpuInfo* cpu);
|
||||
int get_number_of_vpus(struct cpuInfo* cpu);
|
||||
bool choose_new_intel_logo_uarch(struct cpuInfo* cpu);
|
||||
char* get_str_uarch(struct cpuInfo* cpu);
|
||||
char* get_str_process(struct cpuInfo* cpu);
|
||||
void free_uarch_struct(struct uarch* arch);
|
||||
|
||||
@@ -1,23 +0,0 @@
|
||||
#!/bin/bash -u
|
||||
|
||||
CPUID=0x00A50F00
|
||||
|
||||
efamily=$(((${CPUID}>>20)&0xFF))
|
||||
family=$(((${CPUID}>>8)&0xF))
|
||||
emodel=$(((${CPUID}>>16)&0xF))
|
||||
model=$(((${CPUID}>>4)&0xF))
|
||||
stepping=$((${CPUID}&0xF))
|
||||
|
||||
printf 'CPUID: 0x%.8X\n' $CPUID
|
||||
printf -- '- EF = 0x%X (%d)\n' $efamily $efamily
|
||||
printf -- '- F = 0x%X (%d)\n' $family $family
|
||||
printf -- '- EM = 0x%X (%d)\n' $emodel $emodel
|
||||
printf -- '- M = 0x%X (%d)\n' $model $model
|
||||
printf -- '- S = 0x%X (%d)\n' $stepping $stepping
|
||||
|
||||
#EF=$efamily
|
||||
#F=$family
|
||||
#EM=$emodel
|
||||
#M=$model
|
||||
#S=$stepping
|
||||
#grep -E "\s*CHECK_UARCH\(arch,\s*${EF},\s*${F},\s*(${EM}|NA),\s*(${M}|NA),\s*(${S}|NA)" uarch.c
|
||||
Reference in New Issue
Block a user