Index
> DOS > CPUID.com & Fasm source code 8088-P4+ DOSGoto page 1, 2 Next |
| Author |
|
|
bitdog2u 11 Jun 2025, 13:18
Hello, I wrote CPUID.asm cuz I couldn't find any DOS CPUID program that gave me much info on my CPU.
It needs some testing, and improvements, probably. TOTALLY FREEware, except, I ask that you keep a history of it's development in the source code. If you add anything worth having, add your name, date, & short description. You can mark your added code with a unique search string comment. To understand its output, you will probably need to download an INFO file We should do some BETA testing, & fixing before someone uploads it to a .FTP where it probably should be, once it becomes worthy. Any input is good input, so constructive criticism is welcome. If it doesn't work or report correctly on your CPU, please report that. Thanks in advance, Bitdog PS, it is coded to do 8088 to a p4 ? But I don't know what it does without your input. FASM source code included. If you FIX/alter it, please post the worthy updates for us all.
|
|||||||||||
11 Jun 2025, 13:18 |
|
|
bitdog2u 11 Jun 2025, 17:16
#1.My code uses old fashion CPU checks, to find out if the computer can dump out a CPUID, then it does if it can.
So if you had an 8088, the checks would stop at 80186 and the report would be, YOU HAVE AN 8088 and my sympathy. When all the CPU checks prove that the CPU has CPUID, then and only then can CPUID dump out data. Then my CPUID.COM dumps out more data than you really want, it will dump out all the LEAFs your BOX has to give. Then download the info for those LEAFS and you will know what you have. There is some info in my code, but its been years since I used it so I will have to review my own code to give any real answers here. #2. my code should tell you what is in your box weather its is pre CPUID 1993 or after. Most others code can only do after 1993 CPUID and they give the user no info. If that didn't answer your question, ask again, Please. So did you try it ? Did it work ? What did you try it on ? What CPU ? What OS ? Did the code assemble? Did I include everything needed to create an identical copy of the CPUID.COM enclosed. FEED ME SEEMORE. (Little Shop of Horrors quote) PS,the intent of CPUID is for programmers to be ABLE TO WRITE CODE THAT DETERMINES THE ABILITIES OF THE COMPUTER YOUR CODE IS RUNNING ON, and capitalize on that. The multi leafs hold bits to test for MMX and EVERYTHING. Most people think CPUID is designed to tell you what computer you have. For that info, I just look at the receipt. SO with that in mind, you now have the code showing how all that info is gathered, and you can use it to write better programs. I can't. I'm still stuck in 286 mode. |
|||
|
11 Jun 2025, 17:16 |
|
|
Core i7 11 Jun 2025, 18:10
If you display a binary mask, then also need help for each bit, otherwise the user will not see the desired result (i.e. we will get software that needs a large specification on top). Better short, but informative, for example 386+:
Code: use16 org 100h jmp start mess0 db 13,10, ' CPU IDENTIFICATION' db 13,10, ' ******************' db 13,10, ' CPUID...: $' mess1 db 13,10, ' Max LEAF: $' mess2 db 13,10,10,' Vendor..: $' mess3 db 13,10, ' Product.: $' mess4 db 13,10, ' Ext.code: $' mess5 db 13,10,10,' Features:',10,' $' mess10 db 'OK!$' mess20 db 'ERROR!$' FeaturesTable dw @00,@01,@02,@03,@04,@05,@06,@07,@08,@09 ; 10 & 20 reserved dw @10,@11,@12,@13,@14,@15,@16,@17,@18,@19 dw @20,@21,@22,@23,@24,@25,@26,@27,@28,@29 @00 db 'FPU,$' @01 db 'VME,$' @02 db 'DE,$' @03 db 'PSE,$' @04 db 'TSC,$' @05 db 'MSR,$' @06 db 'PAE,$' @07 db 'MCE,$' @08 db 'CMPXCH8,$' @09 db 'APIC,$' @10 db '$' @11 db 'SYSENTER,$' @12 db 'MTRR,$' @13 db 'PGE,$' @14 db 'MCA,$' @15 db 'CMOV,$' @16 db 'PAT,$' @17 db 'PSE-36,$' @18 db 'PSN,$' @19 db 'FLUSH,$' @20 db '$' @21 db 'DBG,$' @22 db 'ACPI,$' @23 db 'MMX,$' @24 db 'FXSR,$' @25 db 'SSE,$' @26 db 'SSE2,$' @27 db 'SS,$' @28 db 'HTT,$' @29 db 'TM,$' buff dd 4 dup(0) ;//--------------------- start: mov dx,mess0 call message call testCPUID ; exit if 0 mov dx,mess1 call message mov eax,0 ; max fn support cpuid mov ebx,10 ; print DEC call convert ;//----- mov dx,mess2 call message mov eax,0 ; vendor cpuid mov dword[buff+0],ebx mov dword[buff+4],edx mov dword[buff+8],ecx mov esi,buff mov cx,12 ; 12 char @cpuLoop: lodsb int 29h loop @cpuLoop ;//----- mov dx,mess3 call message mov eax,80000002h ; CPU name push eax call fnCPU mov ecx,16 @print: lodsb cmp al,' ' jne @next dec ecx jmp @print @next: int 29h loop @print pop eax inc eax @sLoop: push eax call fnCPU mov ecx,16 @print1: lodsb int 29h loop @print1 pop eax inc eax cmp eax,80000004h jbe @sLoop ;//----- mov dx,mess4 call message mov eax,1 ; CPU code cpuid mov ebx,16 ; print HEX call convert ;//----- mov dx,mess5 call message mov eax,1 ; Features cpuid mov si,FeaturesTable mov bx,30 ; bits 0-29 xor ax,ax @printFeat: cmp al,10 ; bit 10 & 20 reserved je @miss cmp al,20 je @miss bt cx,ax ; BitTest jnc @miss push si ax bx ; found! shl ax,1 add si,ax mov dx,[si] call message pop bx ax si @miss: inc al dec bx jnz @printFeat ;//----- @ends: xor ax,ax ; game over! int 16h int 20h ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; message: mov ah,9 int 21h ret testCPUID: pushfd pop eax mov ecx,eax xor eax,40000h push eax popfd pushfd pop eax xor eax,ecx jne no_cpuid mov dx,mess20 call message jmp @ends no_cpuid: mov dx,mess10 call message ret convert: ;<---------- Print EAX xor ecx,ecx @fnDiv: xor edx,edx div ebx ; arg = 16(hex), 10(dec) or 8(oct) push edx inc ecx or eax,eax jnz @fnDiv @fnOut: pop eax cmp al,09 jle @noHex add al,7 @noHex: add al,30h int 29h loop @fnOut ret fnCPU: cpuid mov dword[buff+0],eax mov dword[buff+4],ebx mov dword[buff+8],ecx mov dword[buff+12],edx mov esi,buff ret
Last edited by Core i7 on 11 Jun 2025, 18:45; edited 1 time in total |
||||||||||
|
11 Jun 2025, 18:10 |
|
|||||||||
|
Core i7 11 Jun 2025, 18:21
Yes, I tested your code on my WinXP in VirtualBox, and I got this error (the window doesn't close).
Code: CPUID says your CPU is a: GenuineIntel ђPentium(R) Dual-Core CPU E5200 @ 2.50GHz 0 = Extended Family (E1AX bits 27-20) 1 = Extended Model # (E1AX bits 19-16) 0 = Original OEM processor. (E1AX bits 15-12) = TYPE 13-12 6 = Family (E1AX bits 11-8) 7 = Model # (E1AX bits 7-4) 10 = Stepping ID (E1AX bits 3-0) 13 = max LEAF # (E0AX bits 7-0) 8 = Extended LEAF max # (EAX= 80000000h input) 0 = Brand Index # (E1BX bits 7-0) 8 = CFLUSH Line Size (E1BX bits 15-8) 1 = Initial APIC ID (E1BX bits 31-24) E1CX=Extended, FeatureFlags=E1DX, E2?X= Cache+TLBInfo, E1AX= Signiture 01067Ah LEAF# 10987654321098765432109876543210 10987654321098765432109876543210 BitBar E1AX= 00000000000000010000011001111010b 00000001000000100000100000000000b =E1BX E1CX= 00000100000000001110001110011101b 10111111111010111111101111111111b =E1DX E2AX= 00000101101100001011000100000001b 00000000010101100101011111110000b =E2BX E2CX= 00000000000000000000000000000000b 00101100101101000011000001111101b =E2DX E3AX= 00000000000000000000000000000000b 00000000000000000000000000000000b =E3BX E3CX= 00000000000000000000000000000000b 00000000000000000000000000000000b =E3DX E4AX= 00000100000000000000000100100001b 00000001110000000000000000111111b =E4BX E4CX= 00000000000000000000000000111111b 00000000000000000000000000000001b =E4DX E5AX= 00000000000000000000000001000000b 00000000000000000000000001000000b =E5BX E5CX= 00000000000000000000000000000011b 00000000000000100010001000100000b =E5DX E6AX= 00000000000000000000000000000001b 00000000000000000000000000000010b =E6BX E6CX= 00000000000000000000000000000011b 00000000000000000000000000000000b =E6DX E7AX= 00000000000000000000000000000000b 00000000000000000000000000000000b =E7BX E7CX= 00000000000000000000000000000000b 00000000000000000000000000000000b =E7DX E8AX= 00000000000000000000010000000000b 00000000000000000000000000000000b =E8BX E8CX= 00000000000000000000000000000000b 00000000000000000000000000000000b =E8DX E9AX= 00000000000000000000000000000000b 00000000000000000000000000000000b =E9BX E9CX= 00000000000000000000000000000000b 00000000000000000000000000000000b =E9DX EaAX= 00000111001010000000001000000010b 00000000000000000000000000000000b =EaBX EaCX= 00000000000000000000000000000000b 00000000000000000000010100000011b =EaDX EbAX= 00000000000000000000000000000000b 00000000000000000000000000000000b =EbBX EbCX= 00000000000000000000000000000000b 00000000000000000000000000000000b =EbDX EcAX= 00000000000000000000000000000000b 00000000000000000000000000000000b =EcBX EcCX= 00000000000000000000000000000000b 00000000000000000000000000000000b =EcDX EdAX= 00000000000000000000000000000011b 00000000000000000000001001000000b =EdBX EdCX= 00000000000000000000001001000000b 00000000000000000000000000000000b =EdDX Bits= fedcba9876543210fedcba9876543210 fedcba9876543210fedcba9876543210 LEAF# No CPUID is available. Your CPU is: LEAF# 10987654321098765432109876543210 10987654321098765432109876543210 BitBar E1AX= 00000000000000010000011001111010b 00000001000000100000100000000000b =E1BX E1CX= 00000100000000001110001110011101b 10111111111010111111101111111111b =E1DX E2AX= 00000101101100001011000100000001b 00000000010101100101011111110000b =E2BX E2CX= 00000000000000000000000000000000b 00101100101101000011000001111101b =E2DX E3AX= 00000000000000000000000000000000b 00000000000000000000000000000000b =E3BX E3CX= 00000000000000000000000000000000b 00000000000000000000000000000000b =E3DX E4AX= 00000100000000000000000100100001b 00000001110000000000000000111111b =E4BX E4CX= 00000000000000000000000000111111b 00000000000000000000000000000001b =E4DX E5AX= 00000000000000000000000001000000b 00000000000000000000000001000000b =E5BX E5CX= 00000000000000000000000000000011b 00000000000000100010001000100000b =E5DX E6AX= 00000000000000000000000000000001b 00000000000000000000000000000010b =E6BX E6CX= 00000000000000000000000000000011b 00000000000000000000000000000000b =E6DX E7AX= 00000000000000000000000000000000b 00000000000000000000000000000000b =E7BX E7CX= 00000000000000000000000000000000b 00000000000000000000000000000000b =E7DX E8AX= 00000000000000000000010000000000b 00000000000000000000000000000000b =E8BX E8CX= 00000000000000000000000000000000b 00000000000000000000000000000000b =E8DX E9AX= 00000000000000000000000000000000b 00000000000000000000000000000000b =E9BX E9CX= 00000000000000000000000000000000b 00000000000000000000000000000000b =E9DX EaAX= 00000111001010000000001000000010b 00000000000000000000000000000000b =EaBX EaCX= 00000000000000000000000000000000b 00000000000000000000010100000011b =EaDX EbAX= 00000000000000000000000000000000b 00000000000000000000000000000000b =EbBX EbCX= 00000000000000000000000000000000b 00000000000000000000000000000000b =EbDX EcAX= 00000000000000000000000000000000b 00000000000000000000000000000000b =EcBX EcCX= 00000000000000000000000000000000b 00000000000000000000000000000000b =EcDX EdAX= 00000000000000000000000000000011b 00000000000000000000001001000000b =EdBX EdCX= 00000000000000000000001001000000b 00000000000000000000000000000000b =EdDX Bits= fedcba9876543210fedcba9876543210 fedcba9876543210fedcba9876543210 LEAF# There is an FPU running. But below a 286 there is no MSW (Machine Status Word) to check for FPU emulation. No CPUID is available. Your CPU is: There is an FPU running. But below a 286 there is no MSW (Machine Status Word) to check for FPU emulation. There is an FPU running. But below a 286 there is no MSW (Machine Status Word) to check for FPU emulation. No CPUID is available. Your CPU is: There is an FPU running. But below a 286 there is no MSW (Machine Status Word) to check for FPU emulation. There is an FPU running. But below a 286 there is no MSW (Machine Status Word) to check for FPU emulation. No CPUID is available. Your CPU is: There is an FPU running. But below a 286 there is no MSW (Machine Status Word) to check for FPU emulation. There is an FPU running. But below a 286 there is no MSW (Machine Status Word) to check for FPU emulation. No CPUID is available. Your CPU is: There is an FPU running. But below a 286 there is no MSW (Machine Status Word) to check for FPU emulation. There is an FPU running. But below a 286 there is no MSW (Machine Status Word) to check for FPU emulation. No CPUID is available. Your CPU is: There is an FPU running. But below a 286 there is no MSW (Machine Status Word) to check for FPU emulation. There is an FPU running. But below a 286 there is no MSW (Machine Status Word) to check for FPU emulation. No CPUID is available. Your CPU is: There is an FPU running. But below a 286 there is no MSW (Machine Status Word) to check for FPU emulation. There is an FPU running. But below a 286 there is no MSW (Machine Status Word) to check for FPU emulation. No CPUID is available. Your CPU is: There is an FPU running. But below a 286 there is no MSW (Machine Status Word) to check for FPU emulation. There is an FPU running. But below a 286 there is no MSW (Machine Status Word) to check for FPU emulation. No CPUID is available. Your CPU is: There is an FPU running. But below a 286 there is no MSW (Machine Status Word) to check for FPU emulation. There is an FPU running. But below a 286 there is no MSW (Machine Status Word) to check for FPU emulation. No CPUID is available. Your CPU is: There is an FPU running. But below a 286 there is no MSW (Machine Status Word) to check for FPU emulation. There is an FPU running. But below a 286 there is no MSW (Machine Status Word) to check for FPU emulation. No CPUID is available. Your CPU is: There is an FPU running. But below a 286 there is no MSW (Machine Status Word) to check for FPU emulation. There is an FPU running. But below a 286 there is no MSW (Machine Status Word) to check for FPU emulation. |
|||
|
11 Jun 2025, 18:21 |
|
|
bitdog2u 11 Jun 2025, 22:00
ok Core i7
It is going to take me a bit to digest all this. Can you assemble the code to get an exact CPUID.COM ? Did I forget to include any files ? And is the code acceptable and understandable for you to work with ? It's freeware, so you can alter it. CAN YOU FIX IT FOR XP? And thanks for the input. IO redirect the output CPUID > AFILE.TXT will capture all the output to a file if the screen starts scrolling crap You have a lot more LEAF ACTIVITY than I do, My p4 has leaf2 Since LEAF 0 is practically NO INFO it doesn't count, so I didn't show it. I wanted a program that dumped out all the info. I have never had as much output as you have. I'm really not that great of a programmer. I gots lots of tough talk though. PS, the hard part of my CPUID.com was getting the checks for 8088 to 486 The first CPUID came out on the last 486's, and they were working on it when Pentium came out. I got all the CPU checks I could find and went over about 15 of the most popular checks, I used the best proven ones in a coordination effort and put them all together when no one else did. That is how my code gets to the p4 where CPUID would work. I found the early CPU check code interesting and difficult to work with since there is no wiggle room to OOPs in. So your XP machine survived those 8088 checks. Thanks, I needed that. PS2, I don't know anything about FPU codeing, so my FPU check code area could be an area that really needs someone else to fix. I'll check back later. Last edited by bitdog2u on 12 Jun 2025, 00:22; edited 1 time in total |
|||
|
11 Jun 2025, 22:00 |
|
|
bitdog2u 11 Jun 2025, 23:09
Core i7 says If you display a binary mask, then also need help for each bit, otherwise the user will not see the desired result (i.e. we will get software that needs a large specification on top). Better short, but informative, for example 386+:
I haven't understood that yet, but it looks good, and the output is what most people want. What I wanted was all the LEAFS EXPOSED in a file and I can figure it all out from there. So if there are 15 types of CMPXCHG, the LEAFs will show it, where NICE output struggles with that. I tried coding NICE like that and ended up cutting corners, which is probably why most CPUID programs don't give out much info. My CPUID is kinda only for programmers, where yours is great for humans, so we aren't competing, we are complimenting each other. AND since I'm asking for help, the only thing I have to offer in return is my FREEWARE, if you want to use my 80888 to 486 check code you can have it, copy/paste. IT might make a nice little.com that checks for 8088-486 and has output like yours does. Then yours can take it from there ? IT'S TOTAL FREEWARE Take my name out, and put yours in if you want. But a better way is to keep a history of fixes in the .ASM A short: who, what, where, when info. So here is a WHAT IF for you. WHAT IF, I texted you and said, your program does not run on my computer. You said: What kind of computer do you have exactly? Wait a sec, I will use Bitdogs CPUID.com and send you the > OUTfile.txt .ZIPed. Ok, then I will know EXACTLY WHAT YOU HAVE, without any lies. That was kinda my original goal. Look how many LEAFS your CPU dumps out 13 max LEAFS, that is alot of INFO. you have 10 in STEPPING ID, and I didn't know you were in a FAMILY 6 and your E1DX has bit 31 set, so it's NOT active, like my P4. CPUID H Will show the info that most CPUID programs forget to mention. Because it's too much to mention. WHAT IF #2 if my CPUID.com dumped out LEAF data in byte form and your CPUID accepted the file as input, then output the INTERPRETED versions that humans understand on the screen, we would have something worth having. Of course, you could get yours to output the LEAF data also. Then my CPUID would need to use that raw data file as input to dump out the LEAF data as if we were all on the same team. i hope that helps. |
|||
|
11 Jun 2025, 23:09 |
|
|
Core i7 12 Jun 2025, 03:21
bitdog2u wrote: So here is a WHAT IF for you. Are there any i8088 computers left with an 8-bit bus and a frequency of 5 MHz (maybe only in a museum)? But if you need it for self-education and practical classes, then the documents "CPUID for Intel" have examples in assembler that test CPUs from 8086 to Pentium 4 by flags. See this *.pdf on page 59, although yours seems to have been implemented similarly: https://www.scss.tcd.ie/jeremy.jones/CS4021/processor-identification-cpuid-instruction-note.pdf |
|||
|
12 Jun 2025, 03:21 |
|
|
bitdog2u 12 Jun 2025, 13:36
ok Core i7
You are basically right about everything, but I am still stuck. I have an unfinished program, that needs testing and fixing, then comes my mental problems. The thought that there actually needs to be a CPUID program that can do all COMPUTERS from the first 8088, to ALL the CPUs of the FUTURE returning a COMPLETE INFORMATION OUTPUT, is stuck in my head and it's not going to go away any time soon, and your program doesn't do that output, but mine does. So say something that makes me think I should throw my program in the garbage and use yours, and I will. I like your code that checks for CPUID available, so I will check that out a little more, but I'm doing my MINEZ.com game now, while the code is still fresh in my head. I only released the CPUID.com program because I thought I took it as far as I could and now I NEED HELP, NOT HARM. So thank you for the read out reply. It looks like CPUID.com made it through reporting all your LEAFs, it errored on the EXIT PROGRAM part, or failed on any EXTENDED LEAFs, the 80000000h part? Cuz it LOOPed back and did LEAFs again, then got locked in an endless loop?. I'm going to look into it in a week or so. AND the idea of a small info dump OUTfile.ext that can be a SHARE-able LOAD-able INfile.ext would be a great CPUID.com upgrade. I'm going to look into the recommended .pdf so Thanks for that, but I think I already did and found that they used some of the Seattle Computer DOS Logic CPU checks of the time, but not all and they didn't quite get it right. So I had to shove all the checks done in my head and melt them down to THE REAL CODE and I used that SIMPLIFIED, where INTEL BLOATware failed my needs. And it turns out MY code ran through your 1067A ok as it did my 000F29 so I'm moving forward, & thanks for that also. If I had a huge data base of all Ext.code SIGNATURES I could know your LEAFs by knowing your# 1067A but that is not possible for me to do. There might be internet info available for 1067A but a quickie Google search didn't find anything, YET. So the share a data file idea, is still valid. I do have an XP machine, but I haven't used it in 5 years. So checking CPUID.com on XP DOS box is another project I'm not going to do soon. Any way, THANKS for what you did for me, Nobody else even bothered to say anything. And they are probably spreading my unfinished code around the internet like IDIOTS would do. Then you can expect that they will have to talk bad about me, to make them look good. If they had ethics, they would know better. PS. I thought the i8088 had a 16 bit bus and they came out with the 8086 that had an 8 bit device bus, because most all the devices made at the time were 8 bit, and the 8088 had few usable devices available to it. (tape recorders & 8" floppys ?) I will have to look into it, but it looks like the answer to your question is NO. Are there any i8088 computers left with an 8-bit bus? PS2, because of your help, I'm going to try to be helpful to you in the future, cuz it is easier to help, than to quibble over nothing forever. PS3, Correct me if I'm wrong here but: HELP is when you give a person EXACTLY WHAT THEY ASKED FOR in a timely manner, without any undue burdens. That is HELP because, nothing else helps. A person is MENTALLY STUCK and they need help to get from point A to B, to get UNSTUCK. They know what A & B is, and no one else does. Help is a selfless act, and in return you get NOTHING. Well, you get harmed occasionally. No good deed goes unpunished. BUT there is an up side, if you help others, you feel like you can ask for help, and you do ask, and you do get some help, and I was asking. |
|||
|
12 Jun 2025, 13:36 |
|
|
Core i7 12 Jun 2025, 14:41
@bitdog2u, each person should do what he wants and not listen to anyone. You have planned a program with such an algorithm, and i'am not against it at all. I just want to advise you to spend your energy on something useful, because 8086/88 are no longer used anywhere, and it will be difficult for you to do tests. Or do you have a machine with such a processor?
Secondly, yes, your code has a lot of information, but unfortunately it is understandable only to you - an ordinary user (for whom you write the program) will drown among such a number of bits. Software should provide information to the user, but now he, on the contrary, demands it in the form of documentation on the cpuid. This does not mean that you should abandon your project - I would just reconsider its purpose a little (who you are writing for, and what exactly you want to tell him). PS: do not take this criticism to heart, and perceive programming as a game or a hobby, and not a mandatory job. |
|||
|
12 Jun 2025, 14:41 |
|
|
revolution 12 Jun 2025, 14:51
I personally like it when programs present me with lots of information. I don't like it when programs treat me as dumb or lazy and reduce the amount of information given in an attempt to pander to "normal" people.
People are clever and don't need to be talked down to, IMO. I think it is a great programming experience to make something that is universal, regardless of how "useless" it might appear to be. The exercise alone is worth the effort, IMO. Expand your brain. give everything maximum effort.  |
|||
|
12 Jun 2025, 14:51 |
|
|
bitdog2u 12 Jun 2025, 17:26
Thank you Revolution
Wise words from one with a good reputation and 20656 posts, has meaning. Old 8088 check code in a CPUID program wastes 30 bytes, so there is nothing to even talk about there. While I have you here, would you consider trying my FCV.com ? I use it a lot. You can take the IDEA or the CODE and port it to Windoze or something where others can use it, it you like it. It helps me figure out where I left off on my last .ASM write by the CMP of the last backup file.asm and if there are any changes to a file, it will find and show them. It would be nice to have some feed back too. Last edited by bitdog2u on 12 Jun 2025, 18:00; edited 1 time in total |
|||
|
12 Jun 2025, 17:26 |
|
|
bitdog2u 12 Jun 2025, 17:49
Core i7 you have some real knowledge of CPUID, maybe when i get to the fix it part I can tap that know how.
The 8088 to 486 code check is not required since it has already been done, and I just copied their code. But if someone finds a mistake, the source code is there for them and they can also report it. The wasted 100 bytes is not worth getting worried about. My thinking is backward of yours maybe. I start with looking over the LEAF info one can down load, then ask, does my computer have that stuff, then look at the LEAF output of CPUID.com, and it will tell me EXACTLY WHAT I HAVE. If someone has a problem with one of my programs, I can get CPUID.com to give me ALL THE INFO on their computer's CPU so I can solve the issue maybe. I can't see what is wrong with full disclosure at all. So it's a worthy project, I JUST NEED HELP, is all. |
|||
|
12 Jun 2025, 17:49 |
|
|
Core i7 12 Jun 2025, 19:25
bitdog2u wrote: I can't see what is wrong with full disclosure at all. ..of course there is nothing bad, only the value of information is measured not in quantity, but in quality. The fact that the entire monitor screen will be filled with zeros and ones does not make the program better, otherwise in addition to the cpuid functions you can also print all the MSR registers. On the other hand, you are the developer, so my opinion is not very important. It's just that you asked for criticism - I gave it to you, you asked for tests - I provided them. |
|||
|
12 Jun 2025, 19:25 |
|
|
bitdog2u 12 Jun 2025, 23:36
Core i7
YEP, I tried to get output like yours and couldn't catalogize the data needed like you did. but I did end up with a list, then the list got longer, then there were degrees to to the degrees, & type complications, then my ability to predict the future is really bad compared to others, and so I stuck to THE EXACT PROTOCOL FOR CPUID and dumped out the data without my stupidity injected. So now if a new CPU comes out, my CPUID.com does not need to be updated., but yours does. So I built mine for programmers, cuz I wanted the CPUID info in a readable form cuz i'm a programmer, and yours is best for regular people that want to know what is in their box, not how to program it. YOU AND I TOGETHER ARE THE BEST OF BOTH WORLDS. We don't compete. You can use anything of mine in any way you want. It's freeware, but it comes with a warning. YOU ARE WHAT YOU DO, and will be treated accordingly. Me too. My CPUID.com not only fills a screen with zeros and ones, but multi screens of gibberish, scroll by on newer CPUs so the > IO dumps the data to an outfile and you can check it out as you go. Those useless zeros and ones scrolling by are needed to discover what your CPU is, will do, & whats under the hood. Most of which is not needed, but it's there if you do need it. If you are a programmer, you can down load the CPUID description file which is much like the data dump from my CPUID ? on the command line. it turns out that it is a big learning lesson, that can make a better programmer out of anyone. i don't know about MSR registers, but I'll look into it. What do you think a programmer really needs? I'm thinking that if I wanted to learn to use a CPU full capibilities, i would need a full data dump of CPUID then down load the latest CPUID info file. Once i determined what I had on board, I could expierment with coding for it. yes/no/maybe/ hell no ? PS, I'm kinda under the impression that my release of CPUID.com has upset your Ballance somehow. I can work with blunt honest truths, but diplomacy and other forms of nice falsehoods, cause me problems. So what is really on your mind my friend. AND how can I help ? We are both in the same boat and have, at least, CPUID in common. A good warning is: I don't compete, I work with those I can work with, towards a common & worthwhile goal. Last edited by bitdog2u on 13 Jun 2025, 08:37; edited 1 time in total |
|||
|
12 Jun 2025, 23:36 |
|
|
Core i7 13 Jun 2025, 03:04
bitdog2u wrote: Any input is good input, so constructive criticism is welcome If you ask for criticism, learn to perceive it correctly. There is a page sysinternals.com of the famous developer of system software Mark Russinovich. In the archive he offers there are 125 free programs, among which there is "coreinfo.exe" for printing cpuid. This is one of 1000 examples that answers the question, "why does the author not output binary dumps of all Leaf queries, but in a long cycle checks each bit and prints its txt representation?". The answer here is obvious - because programs of this class must carry a useful load for the user. Your program will be unique in its kind not because it prints all the data in BIN (this is the simplest approach), but because in this form it is not needed by the general public. Your code is designed specifically for ordinary users, because if necessary, any programmer himself will write 10 lines of code to check several bits from cpuid in his application. Here is the log of Mark's program "coreinfo.exe" and at the end a screenshot of my utility (which I wrote in 2020 for myself, I can post the entire source code here). If you do not take into account the minor capabilities of the latest processors, this is all the information that can be obtained from cpuid, and it is not as much as you imagine: Code: F:\>coreinfo Coreinfo v3.31 - Dump information on system CPU and memory topology Copyright (C) 2008-2014 Mark Russinovich Sysinternals - www.sysinternals.com Pentium(R) Dual-Core CPU E5200 @ 2.50GHz Intel64 Family 6 Model 23 Stepping 10, GenuineIntel Microcode signature: 00000A0B HTT * Hyperthreading enabled HYPERVISOR - Hypervisor is present VMX - Supports Intel hardware-assisted virtualization SVM - Supports AMD hardware-assisted virtualization X64 * Supports 64-bit mode SMX - Supports Intel trusted execution SKINIT - Supports AMD SKINIT NX * Supports no-execute page protection SMEP - Supports Supervisor Mode Execution Prevention SMAP - Supports Supervisor Mode Access Prevention PAGE1GB - Supports 1 GB large pages PAE * Supports > 32-bit physical addresses PAT * Supports Page Attribute Table PSE * Supports 4 MB pages PSE36 * Supports > 32-bit address 4 MB pages PGE * Supports global bit in page tables SS * Supports bus snooping for cache operations VME * Supports Virtual-8086 mode RDWRFSGSBASE - Supports direct GS/FS base access FPU * Implements i387 floating point instructions MMX * Supports MMX instruction set MMXEXT - Implements AMD MMX extensions 3DNOW - Supports 3DNow! instructions 3DNOWEXT - Supports 3DNow! extension instructions SSE * Supports Streaming SIMD Extensions SSE2 * Supports Streaming SIMD Extensions 2 SSE3 * Supports Streaming SIMD Extensions 3 SSSE3 * Supports Supplemental SIMD Extensions 3 SSE4a - Supports Streaming SIMDR Extensions 4a SSE4.1 - Supports Streaming SIMD Extensions 4.1 SSE4.2 - Supports Streaming SIMD Extensions 4.2 AES - Supports AES extensions AVX - Supports AVX intruction extensions FMA - Supports FMA extensions using YMM state MSR * Implements RDMSR/WRMSR instructions MTRR * Supports Memory Type Range Registers XSAVE * Supports XSAVE/XRSTOR instructions OSXSAVE * Supports XSETBV/XGETBV instructions RDRAND - Supports RDRAND instruction RDSEED - Supports RDSEED instruction CMOV * Supports CMOVcc instruction CLFSH * Supports CLFLUSH instruction CX8 * Supports compare and exchange 8-byte instructions CX16 * Supports CMPXCHG16B instruction BMI1 - Supports bit manipulation extensions 1 BMI2 - Supports bit manipulation extensions 2 ADX - Supports ADCX/ADOX instructions DCA - Supports prefetch from memory-mapped device F16C - Supports half-precision instruction FXSR * Supports FXSAVE/FXSTOR instructions FFXSR - Supports optimized FXSAVE/FSRSTOR instruction MONITOR * Supports MONITOR and MWAIT instructions MOVBE - Supports MOVBE instruction ERMSB - Supports Enhanced REP MOVSB/STOSB PCLMULDQ - Supports PCLMULDQ instruction POPCNT - Supports POPCNT instruction LZCNT - Supports LZCNT instruction SEP * Supports fast system call instructions LAHF-SAHF * Supports LAHF/SAHF instructions in 64-bit mode HLE - Supports Hardware Lock Elision instructions RTM - Supports Restricted Transactional Memory instructions DE * Supports I/O breakpoints including CR4.DE DTES64 * Can write history of 64-bit branch addresses DS * Implements memory-resident debug buffer DS-CPL * Supports Debug Store feature with CPL PCID - Supports PCIDs and settable CR4.PCIDE INVPCID - Supports INVPCID instruction PDCM * Supports Performance Capabilities MSR RDTSCP - Supports RDTSCP instruction TSC * Supports RDTSC instruction TSC-DEADLINE - Local APIC supports one-shot deadline timer TSC-INVARIANT - TSC runs at constant rate xTPR * Supports disabling task priority messages EIST * Supports Enhanced Intel Speedstep ACPI * Implements MSR for power management TM * Implements thermal monitor circuitry TM2 * Implements Thermal Monitor 2 control APIC * Implements software-accessible local APIC x2APIC - Supports x2APIC CNXT-ID - L1 data cache mode adaptive or BIOS MCE * Supports Machine Check, INT18 and CR4.MCE MCA * Implements Machine Check Architecture PBE * Supports use of FERR#/PBE# pin PSN - Implements 96-bit processor serial number PREFETCHW * Supports PREFETCHW instruction Maximum implemented CPUID leaves: 0000000D (Basic), 80000008 (Extended). Logical to Physical Processor Map: *- Physical Processor 0 -* Physical Processor 1 Logical Processor to Socket Map: ** Socket 0 Logical Processor to NUMA Node Map: ** NUMA Node 0 No NUMA nodes. Logical Processor to Cache Map: *- Data Cache 0, Level 1, 32 KB, Assoc 8, LineSize 64 *- Instruction Cache 0, Level 1, 32 KB, Assoc 8, LineSize 64 -* Data Cache 1, Level 1, 32 KB, Assoc 8, LineSize 64 -* Instruction Cache 1, Level 1, 32 KB, Assoc 8, LineSize 64 ** Unified Cache 0, Level 2, 2 MB, Assoc 8, LineSize 64 Logical Processor to Group Map: ** Group 0
|
||||||||||
|
13 Jun 2025, 03:04 |
|
|||||||||
|
bitdog2u 13 Jun 2025, 08:24
Core i7
Now that is useful information and tells me where you are coming from on this chat. I needed that. I haven't digested the info, so I have no comment, yet. I'll probably need a week on this one. thanks again. Just for a hoot, do you think a visual file compare program might be useful to you ? AND since you have real skills, would you consider porting it to Windoze of something others can use ? AND, I use NC.exe a lot and after years of using it, I accidentally bumped the CTRL+J key with a space in front of the cursor on the command line, and it put the highlighted file name in the command prompt. Now I can quickly make a big command without type O's Do you use NC.exe ? and have you heard of that command? and is there any README.txt file for NC.exe operations that you know of ? |
|||
|
13 Jun 2025, 08:24 |
|
|
Core i7 13 Jun 2025, 11:24
All utilities for printing cpuid (both yours and mine) are designed only for users. But programmers do not need such software, since in practice they never request all the bits in all Leafs at once. For example, we write a game on AVX instructions, and if it gets on an old CPU, it will not work. Here we need a call to cpuid, as a result of which the programmer jumps to a similar block of the game, only with outdated SSE instructions (or displays an error message). That is, at any given time, some one/two capabilities of the CPU are checked, and it is difficult to come up with a situation when a programmer needs everything at once:
Code:
mov eax,1
cpuid
bt ecx,28 ; check AVX bit..
jc @support ; if sets
;... use SSE instruction
@support:
;... use AVX
That's why I say that you already have binary dumps, and all that's left is to add lines to them. You can turn on text video mode(3) 80x25/16, and for easy navigation via int-10h AX=05xxh, scatter all the information across 4 separate pages of the video mode. This way, the data on the screen won't get lost, and you can use the arrows on the keyboard to scroll through cpuid like a book. Here's an example: Code: org 100h start: mov ax,3 ; Vmode 80x25 /16 int 10h ;// Default page 1 call @f db 13,10,' ***********************************' db 13,10,' Page(1) - paste text & binary info' db 13,10,' ***********************************$' @@: pop dx call message mov ax,0501h ;<------ Set active page 2 int 10h call @f db 13,10,' ***********************************' db 13,10,' Page(2) - paste text & binary info' db 13,10,' ***********************************$' @@: pop dx call message mov ax,0502h ;<------ Set active page 3 int 10h call @f db 13,10,' ***********************************' db 13,10,' Page(3) - paste text & binary info' db 13,10,' ***********************************$' @@: pop dx call message mov ax,0503h ;<------ Set active page 4 int 10h call @f db 13,10,' ***********************************' db 13,10,' Page(4) - paste text & binary info' db 13,10,' ***********************************$' @@: pop dx call message ;// Show default Page(1) mov ax,0500h int 10h @SetPage: xor ax,ax ; wait key.. int 16h cmp ah,1 ; scan-code Esc jnz @f int 20h @@: cmp ah,4Dh ; right key je @right cmp ah,4Bh ; left key jne @SetPage mov ah,05 ;<----- Backward step mov al,[CurrentPage] cmp al,0 jz @SetPage dec al mov [CurrentPage],al int 10h jmp @SetPage @right: mov ah,5 ;<----- Forward step mov al,[CurrentPage] cmp al,3 jz @SetPage inc al mov [CurrentPage],al int 10h jmp @SetPage message: mov ah,9 int 21h ret CurrentPage db 0 And I haven't launched pure MS-DOS (not vdm) for 20 years, even on virtual machines, so I can't say anything about NC and files. Now I often boot without an OS only under BIOS, since tests at work require it. |
|||
|
13 Jun 2025, 11:24 |
|
|
macomics 13 Jun 2025, 12:36
I can suggest this code to switch to 80*50 mode.
Code: struc VideoConfig { .display db ? ; 0 - MONO, 1 - COLOR .adapter db ? ; 0 - MDA, 1 - CGA, 2 - EGA, 3 - VGA, 255 - not initialized .mode db ? ; Active display mode .active db ? ; Active video page .width db ? ; Number of columns .height db ? ; Number of rows .videomem dw ? ; Current video memory segment } GetVideoMode: push bp mov ax, 6656 int 16 xor cx, cx cmp al, 26 jnz .ega cmp bl, 2 jz .ok jc @f cmp bl, 5 jbe .ega mov cx, 1 ; MDA, COLOR cmp bl, 8 ja @f mov ch, 3 ; VGA jz @f xor cl, cl ; VGA, MONO jmp @f .ega: mov ah, 18 mov bl, 16 int 16 jcxz .cga mov cx, 512 ; EGA, MONO or bh, bh jnz @f inc cl jmp @f .cga: int 17 xor cx, cx ; MDA, MONO and al, 48 cmp al, 48 jz @f .ok: mov cx, 257 ; CGA, COLOR @@: mov word [videoconf.display], cx mov ah, 15 int 16 mov [videoconf.mode], al mov [videoconf.active], bh mov [videoconf.width], ah mov [videoconf.height], 25 cmp al, 7 jz @f cmp al, 3 jz @f cmp al, 2 jz @f mov ax, 131 int 16 @@: mov al, [videoconf.display] cbw shl ax, 11 add ax, 0xB000 add ah, [videoconf.active] mov [videoconf.videomem], ax cmp [videoconf.adapter], 2 jc @f mov ax, 4400 xor bh, bh int 16 mov [videoconf.height], dl @@: pop bp retn IsVGA: cmp [videoconf.adapter], 255 jc @f call GetVideoMode @@: mov al, [videoconf.adapter] and al, 3 cmp al, 3 jnz @f mov al, 1 retn @@: xor al, al retn Set80x50Mode: call IsVGA test al, al jz @f mov ax, 0x1202 mov bl, 48 int 16 mov ax, 3 int 16 mov ax, 0x1112 xor bl, bl int 16 mov ah, 18 mov bl, 32 int 16 mov cx, 0x0006 mov ah, 1 int 16 clc retn @@: stc retn if ~ defined videoconf | defined @f videoconf VideoConfig @@: store byte 255 at videoconf.adapter end if ADD: Here's another one of my old (unfinished) projects. I'm just using this text mode there.
|
|||||||||||
|
13 Jun 2025, 12:36 |
|
|
Mat Qua sar 13 Jun 2025, 16:13
macomics wrote:
Interesting project, your HEX_EDIT OS.
|
||||||||||
|
13 Jun 2025, 16:13 |
|
|||||||||
| Goto page 1, 2 Next < Last Thread | Next Thread > |
Forum Rules:
|