[C++]Unire più file .exe

[gugoXX]

Originariamente inviato da ^TiGeRShArK^

fichissimo, pure io ho un Q6600@3.0 sulla mia workstation

NVidiaaaa... il mio e' solo un E6600 @ 3000 (a casa)
Mi ha tirato fuori solo 2 CPU infatti.

[^TiGeRShArK^]

Originariamente inviato da gugoXX

NVidiaaaa... il mio e' solo un E6600 @ 3000 (a casa)
Mi ha tirato fuori solo 2 CPU infatti.

ah vabbè...non avevo fatto caso al numero di cpu
a casa cmq io ho solo un athlon 64 3000+@4000+ come pc fisso...
Il q6600 è al lavoro....
Però in effetti mi sto consolando col nuovo mac book pro

[cionci]

Originariamente inviato da cdimauro

Ti ho dimostrato con un esempio "minchione" (leggi: è un banale "proof of concept") che posso accedere tranquillamente all'hardware anche con Python, e per far questo mi affido a una libreria che è stata scritta allo scopo e che fornisce esempi esclusivamente in C++ e C#.

Scusa, ma se la libreria che legge quello che serve al nostro amico non esiste...se la scrive da solo ? Per questo ho consigliato C#, perché con un solo strumento può fare tutto ciò che gli serve. Al contrario con Python dovrebbe impararsi a scrivere la libreria in C# o C++ e poi usarla con Python. Hai capito ora cosa intendo ?

[wizard1993]

Originariamente inviato da cionci

Scusa, ma se la libreria che legge quello che serve al nostro amico non esiste...se la scrive da solo ? Per questo ho consigliato C#, perché con un solo strumento può fare tutto ciò che gli serve. Al contrario con Python dovrebbe impararsi a scrivere la libreria in C# o C++ e poi usarla con Python. Hai capito ora cosa intendo ?

scusate l'intromissione, sono perfettamente d'accordo con te cionci. non ha senso in python dover utilizzare una libreria in c++, a quel punto si usa la piattaforma .net
io modificherei l'affermazione di cdimauro così:"In python, we often trust"

[cdimauro]

Originariamente inviato da gugoXX

Ma, sinceramente volevo provare a vedere se sarei riuscito a tirare fuori quello che serviva al nostro amico all'inizio, ovvero
-Frequenza CPU, nome CPU, Frequenza BUS e temperature.
I primi sono li', ma sono anche poi riuscito a tirare fuori la temperatura.

Mumble. Per il nome della CPU OK, ma per frequenza e bus non so se sono quelli fissi (rilevati alla partenza del s.o.) oppure calcolati dinamicamente.

Considerato lo scopo del progetto (che è orientato per gli overclocker), propenderei per la seconda, ma bisogna vedere, appunto, cosa viene restituito dalle classi WMI.

Comunque non e' una libreria generica.
E' l'incapsulamento di tutta la WMI messa a disposizione per .net, direttamente dalla Microsoft.
E' davvero immensa, penso che in qualche modo abbiano anche portato fuori le informazioni della CPUID, ma non ne sono sicuro.

Fra le sole Win32_Classes c'e' da sbizzarrirsi. Riporto qui un elenco
http://msdn2.microsoft.com/en-us/lib...84(VS.85).aspx

Ho fatto qualche ricerca, ma non ho trovato nulla su Win32_Classes e CPUID. Ho recuperato questa http://msdn2.microsoft.com/en-us/lib...73(VS.85).aspx ma parla di CPUID soltanto per quanto riguarda il tipo di processore:

ProcessorId
Data type: string
Access type: Read-only

Processor information that describes the processor features. For an x86 class CPU, the field format depends on the processor support of the CPUID instruction. If the instruction is supported, the property contains 2 (two) DWORD formatted values. The first is an offset of 08h-0Bh, which is the EAX value that a CPUID instruction returns with input EAX set to 1. The second is an offset of 0Ch-0Fh, which is the EDX value that the instruction returns. Only the first two bytes of the property are significant and contain the contents of the DX register at CPU reset—all others are set to 0 (zero), and the contents are in DWORD format.

Ce ne sono anche tante altre. La temperatura (in decimi di Kelvin!!) l'ho trovata qui dentro, in mezzo ad altre cose.
root\WMI MSAcpi_ThermalZoneTemperature
I valori non sono tutti in sola lettura. Per esempio ho potuto cambiare la frequenza di campionamento della temperatura. Non mi ha dato errore, ma non ho controllato se e' stata recepita.
Ovviamente la tua utenza deve avere i privilegi per farlo, tipicamente administrator.

Sì, dipende dalle informazioni a cui vuoi accedere e/o modificare. Per la CPUID non ce n'è bisogno: con un account limitato viene eseguita senza problemi.

Se vuoi provare a leggere la WMI direttamente in Python con l'SDK puoi farlo, ma non so se e' altrettanto agevole.
Le classi bisogna scriverle almeno una volta, e io non l'ho dovuto fare perche' erano gia' tutte belle pronte.

Ma non sono classi .NET? Se è così, dovrebbero essere accessibili senza problemi da IronPython...

Comunque per la sola CPUID e' chiaro che il programma e' una palla, il 90% delle tue righe erano solo la descrizione di ciascuno dei bit.

Esattamente. Ma volevo spedire in output qualcosa di umanamente comprensibile...

Se proprio dovessi eseguirla prenderei la strada con il minimo sforzo.
Poiche' in .net posso linkare progetti che arrivano da diversi linguaggi, nella soluzione aggiungerei semplicemente un progetto C++, con una sola funzione, il cui corpo sarebbe

public int getCPUID()
{
  int ret;
  __asm{
      mov eax, 1
      cpuid
      mov ret, eax
  }
  return ret;
}

Dovrebbe funzionare anche al di fuori del ring0, ma mi riservo di provare.

Sì, funziona, ma per le altre istruzioni, tipo quelle per accedere ai machine register, serve essere in ring0.

Comunque l'approccio di cui sopra ti costringerebbe comunque a doverti scrivere un driver per poter lavorare in ring0 e accedere a tutte le informazioni che ti servono.

Considerato che la libreria che ho usato fa già tutto, sarebbe come reinventarsi la ruota...

Tra l'altro ha driver certificati MS e funziona su qualunque versione di Windows, anche x64 (io l'ho provata con Python a 32 bit su Vista x64 con utenza limitata).

In C# poi, per trasformare l'intero nei singoli bit userei semplicemente:

BitArray ba = new BitArray(BitConverter.GetBytes(fromCPUID));

Da li' si tratterebbe solo di stampare le stringhe pallosissimamente messe.

Certamente.

Originariamente inviato da fek

E meno leggibile.
Piu' corto non vuol dire migliore, piu' leggibile e piu' mantenibile. Meno punti funzionali vuol dire (generalmente) piu' semplice, non meno caratteri.

Ma io avevo scritto questo:

simile (e corto)

in risposta a questo:

quanto codice

che aveva scritto gugoXX.

Volevo semplicemente sottolineare che con IronPython non ci sarebbero state sostanziali differenze (ho parlato di codice "simile", infatti), e visto che il codice di gugoXX è corto, sarebbe stato corto anche quello con IP.

Non ho parlato di codice più o meno corto né tanto meno di maggior o minor leggibilità.

Tu invece stai ipotizzando che sarebbe meno leggibile, senza nemmeno averlo visto.

Possibilissimo (conoscendomi ), ma chi ti dice che non venga fuori un codice almeno leggibile quanto quello in C# (sarebbe sufficiente "ricalcare" la struttura di quello in C#)?

Secondo me in molti esempi di Python che ti ho visto scrivere fai un errore: ti fai prendere dallo scrivere "cute code" sfruttando caratteristiche del linguaggio. E questo e' sbagliato. Io spesso non capisco a prima vista il codice che riporti in Python, lo devo rileggere, poi andarmi a guardare quello che scrivi e cercare la caratteristica del linguaggio che hai usato.

Al contrario, spesso, io faccio leggere il mio codice ad un artista e se mi dice che non capisce quello che sto facendo, quando ho tempo, lo riscrivo in maniera piu' chiara.

Le caratteristiche del linguaggio vanno usate per scrivere codice piu' chiaro e leggibile, non perche' fa figo.

E ora per cortesia non riportarmi un paio di righe di Python dicendo "a me sembrano chiare", perche' nove su dieci lo sembrano solo a te e a chi conosce bene Python

Lo so, e infatti ho cercato di scrivere un codice che fosse più leggibile anche per gli altri.

Ad esempio questa:

def BitSetToStringList(Value, Names):
  List = []
  for Name in Names:
    if Name and (Value & 1):
      List.append(Name)
    Value >>= 1
  return List

l'avrei potuta scrivere usando una list comprehension in una sola (complessa) riga , ma poi saresti sceso da Guildford con la mazza ferrata di Zio Paperone per prendermi a randellate...

Questa mi sembra invece piuttosto leggibile per chiunque, no?

Comunque rivedendo il sorgente che avevo postato mi sono reso conto che utilizzando una variabile "intermedia" per memorizzare il risultato di una list comprehension, il codice diverrebbe più leggibile. Ad esempio questo:

def c_intToStr(Value):
  return ''.join(chr((Value >> Shift) & 255) for Shift in (0, 8, 16, 24))

si potrebbe scrivere così:

def c_intToStr(Value):
  Characters = (chr((Value >> Shift) & 255) for Shift in (0, 8, 16, 24))
  return ''.join(Characters)

Usando una funzione di supporto verrebbe ancora meglio:

def c_intToStr(Value):

  def ConvertByteToCharacter(Shift):
    return chr((Value >> Shift) & 255)

  Characters = (ConvertByteToCharacter(Shift) for Shift in (0, 8, 16, 24))
  return ''.join(Characters)

Dipende tutto da quello che si vuole ottenere...

Originariamente inviato da cionci

Scusa, ma se la libreria che legge quello che serve al nostro amico non esiste...se la scrive da solo ? Per questo ho consigliato C#, perché con un solo strumento può fare tutto ciò che gli serve. Al contrario con Python dovrebbe impararsi a scrivere la libreria in C# o C++ e poi usarla con Python. Hai capito ora cosa intendo ?

A parte il fatto che con IronPython, che è un linguaggio .NET, si potrebbe fare lo stesso tutto, visto che può benissimo "consumare" tutte le classi messe a disposizione dal framework oppure altre "esterne", per quello che deve farci http://www.hwupgrade.it/forum/showpo...92&postcount=1 http://www.hwupgrade.it/forum/showthread.php?p=21295820 "Mazda" (visto che dovremmo rimanere in topic, no? ) non ha certo bisogno di andare a scriversi dei driver, come gli era stato suggerito in precedenza.

Quella di andare a smanettare con l'hardware è un'esigenza vecchia quanto il cucco, e da "secoli" sono disponibili soluzioni (come quella che ho impiegato): basta cercarle e usarle.

Fino a Windows ME era possibile accedere direttamente all'hardware, ma con Windows NT, e in ogni caso da Windows 2000 in poi, ciò non è più possibile e bisogna necessariamente ricorrere a un driver e/o libreria. Che qualcuno, appunto, ha scritto.

Rimane semplicemente da interfacciarvisi, e ho postato un esempio con Python che dimostra quanto ciò sia semplice. O non sei d'accordo?
Stessa cosa si può fare con C++ o C#, di cui il pacchetto fornisce include / namespace ed esempi (molto più facile: io ho dovuto scrivermi tutto da zero, anche se ho impiegato pochissimo ).

Non vedo quale sia il problema, quindi.

Questo, ripeto, non volendo considerare come soluzione IronPython, ma semplicemente Python.

Originariamente inviato da wizard1993

scusate l'intromissione, sono perfettamente d'accordo con te cionci. non ha senso in python dover utilizzare una libreria in c++, a quel punto si usa la piattaforma .net
io modificherei l'affermazione di cdimauro così:"In python, we often trust"

Vedi sopra: per .NET c'è IronPython che può "consumare" qualunque classe scritta per questo framework.

Tra l'altro se il framework .NET non permette di accedere a tutte le informazioni necessarie (e finora mi sembra che alcune manchino), giocoforza anche con C# sarà necessario rivolgersi a una libreria come quella che ho usato, oppure reinventarsi la ruota appoggiandosi a C++/CLR per realizzare le API / classi necessarie.

Nessuna differenza con C#, quindi.

Mah. Mi sembra una polemica inutile...

[Mazda RX8]

quindi ke linguaggio devo usare... sembra più semplice qsto phyton...

[cdimauro]

Se:
- non devi scrivere un driver;
- il tuo scopo rimane esattamente quello che hai esposto qui http://www.hwupgrade.it/forum/showpo...&postcount=10;
- come programmazione sei più bianco di un lenzuolo e devi, quindi, imparare partendo dalle basi;

POTRESTI (metto il condizionale, altrimenti qui mi crocifiggono nuovamente, pur essendo in topic; vedi punto 2 qui sopra) prendere in seria considerazione Python (o IronPython se le classi della libreria standard .NET permettono di estrapolare TUTTE le informazioni che ti servono).

[dupa]

Originariamente inviato da Mazda RX8

quindi ke linguaggio devo usare... sembra più semplice qsto phyton...

io che sono un Javista e che quindi non sono nè un fan boy di Python nè di .NET ti consiglio di farlo in C#.

ciao

[fek]

Originariamente inviato da cdimauro

l'avrei potuta scrivere usando una list comprehension in una sola (complessa) riga , ma poi saresti sceso da Guildford con la mazza ferrata di Zio Paperone per prendermi a randellate...

Ti avrei preso a randellate fino allo sfinimento

[cdimauro]

Quello lo farai sicuramente. Prevedo 4 mesi terribili per me, pensando che dovrai lavorare con la tool chain scritta in Python fino alla chiusura di Fable 2...

[okay]

fek, cdimauro... grandi!

ma anche gugoXX... cionci gran mediatore

ma anche gli altri del 3d...

da okay per hobby

ciao vado a cuccia... sono alticcio anche stasera


ciao


Edit: Mazda RX8 sei in un momento fortunato... sfruttalo e inizia a digitare!!!

[cdimauro]

Ho rifattorizzato un po' il codice per renderlo più leggibile, e ho introdotto anche il calcolo della frequenza della CPU usando il timestamp (che, col Cool'n'Quite di mezzo, è abbastanza impreciso; comunque avevo voglia di provare qualcosa di nuovo ):

import threading, time
from ctypes import *
hw = windll.WinRing0

def c_intToString(Value):

  def ConvertByteToCharacter(Shift):
    return chr((Value >> Shift) & 255)

  Characters = (ConvertByteToCharacter(Shift) for Shift in (0, 8, 16, 24))
  return ''.join(Characters)


def c_intToNibbles(Value):

  def ConvertToNibble(Shift):
    return (Value >> Shift) & 15

  Nibbles = (ConvertToNibble(Shift) for Shift in(0, 4, 8, 12, 16, 20, 24, 28))
  return tuple(Nibbles)


def CPUIDFunctionToString(Function):

  eax, ebx, ecx, edx = CPUID(Function)
  return c_intToString(eax) + c_intToString(ebx) + c_intToString(ecx) + c_intToString(edx)


def BitSetToStringList(Value, Names):
  List = []
  for Name in Names:
    if Name and (Value & 1):
      List.append(Name)
    Value >>= 1
  return List



class WaitingThread(threading.Thread):

  def run(self):

    global TimeElapsed

    time.sleep(10)
    TimeElapsed = True



def CPUID(Function):

  eax = c_int(); ebx = c_int(); ecx = c_int(); edx = c_int()
  hw.Cpuid(Function, byref(eax), byref(ebx), byref(ecx), byref(edx))

  return eax.value, ebx.value, ecx.value, edx.value


def RDTSC():

  eax = c_int(); edx = c_int()
  hw.Rdtsc(byref(eax), byref(edx))
  return eax.value + (edx.value << 32)


EDXFeatures = ('Floating-point unit on-Chip',
  'Virtual Mode Extension',
  'Debugging Extension',
  'Page Size Extension',
  'Time-Stamp Counter',
  'Model Specific Registers',
  'Physical Address Extension',
  'Machine Check Exception',
  'CMPXCHG8 Instruction Supported',
  'On-chip APIC Hardware Supported',
  '',
  'Fast System Call',
  'Memory Type Range Registers',
  'Page Global Enable',
  'Machine Check Architecture',
  'Conditional Move Instruction Supported',
  'Page Attribute Table',
  '36-bit Page Size Extension',
  'Processor serial number is present and enabled',
  'CLFLUSH Instruction supported',
  '',
  'Debug Store', 
  'Thermal Monitor and Software Controlled Clock Facilities supported',
  'Intel Architecture MMX technology supported',
  'Fast floating point save and restore',
  'Streaming SIMD Extensions supported',
  'Streaming SIMD Extensions 2',
  'Self-Snoop',
  'Multi-Threading',
  'Thermal Monitor supported',
  'IA64 Capabilities',
  'Pending Break Enable')

ECXFeatures = ('Streaming SIMD Extensions 3',
  '',
  '64-Bit Debug Store',
  'MONITOR/MWAIT',
  'CPL Qualified Debug Store',
  'Virtual Machine Extensions',
  'Safer Mode Extensions',
  'Enhanced Intel SpeedStep Technology',
  'Thermal Monitor 2',
  'Supplemental Streaming SIMD Extensions 3',
  'Context ID',
  '',
  '',
  'CMPXCHG16B',
  'Send Task Priority Messages',
  'Performance Capabilities MSR',
  '',
  '',
  'Direct Cache Access',
  'Streaming SIMD Extensions 4.1',
  'Streaming SIMD Extensions 4.2',
  '',
  '',
  'POPCNT instruction',
  '',
  '',
  '',
  '',
  '',
  '',
  '',
  'RAZ')


hw.InitializeDll()
try:
  eax, ebx, ecx, edx = CPUID(0)
  print 'CPU VendorID is:', c_intToString(ebx) + c_intToString(edx) + c_intToString(ecx)

  Brand = CPUIDFunctionToString(0x80000002) + CPUIDFunctionToString(0x80000003) + CPUIDFunctionToString(0x80000004)
  NoZeroCharsBrand = (Ch for Ch in Brand if Ch != '\x00')
  print 'CPU Brand is:', ''.join(NoZeroCharsBrand)

  eax, ebx, ecx, edx = CPUID(1)
  print 'CPU Stepping: %s, Model: %s, Family: %s, Processor Type: %s' % c_intToNibbles(eax)[ : 4]

  print 'CPU Features:'
  for Feature in BitSetToStringList(edx, EDXFeatures) + BitSetToStringList(ecx, ECXFeatures):
    print ' ', Feature

  TimeElapsed = False
  StartCounter = RDTSC()
  WaitingThread().start()
  while not TimeElapsed:
    pass
  StopCounter = RDTSC()
  if StartCounter > StopCounter:
    StartCounter, StopCounter = StopCounter, StartCounter
  print 'CPU is running at (about) %s Mhz' % ((StopCounter - StartCounter) / 10000000)

finally:
  hw.DeinitializeDll()

C'è pure un esempio di utilizzo dei thread in Python (che è veramente banale: guardare credere ).

Per adesso è tutto.

Buonanotte

[gugoXX]

Vabbe' basta.
Lo faccio in C# (e qualcosa di C++/asm) proprio perche' cosi' poi studiamo i confronti di linguaggio.
A vista continuo a sostenere che non ci sia cosi' grande differenza.
spero che la CPUID possa essere usata anche dal ring3, altrimenti lascio.

Per intanto leggendo il tuo codice ho visto che devo restituire 4 registri e non 1 solo. Dal C++ lo saprei fare in modo semplice con una struct (cosi' evito marshaling pesanti verso il C#). Qualche altro suggerimento?

Poi ho trovato un punto da migliorare ovvero la tua funzione
BitSetToStringList
Non ho ancora piena proprieta' di LINQ, ma se tutto va bene provo a stupirti un po' li'.

I nibble fanno proprio pena pero' cribbio. Ma come gli e' venuto in mente? Usare i nibble... vabbe'. Mi sa che copio il tuo codice perche' non mi viene in mente nulla di meglio.

[gugoXX]

Per intanto ho testato la CPUID e funziona anche in Ring3, cosi' abbiamo la fattibilita'.
Questo e' il codice C++ della parte che ci serve.
Dato un intero (il parametro), restituisco al C# la struttura riempita con i 4 registri.

Niente privilegi, call gate o simili. Meno male.
Qualcuno sa se posso "condividere" la definizione della struttura tra C# e C++?
Intendo, so che non sono la stessa cosa, ma la scrittura e' praticamente identica.
Si possono "includere" in entrambi i posti?
Boh, comunque non si muore, sono 5 righe, ma e' solo per saperlo, magari per il futuro (anche se sto per cambiare lavoro, e non penso proprio di usare il C++ neppure li')

#define DllExport   __declspec( dllexport )
typedef struct 
{
	int reg_eax;
	int reg_ebx;
	int reg_ecx;
	int reg_edx;
} REGS;

DllExport REGS GetCPUID(unsigned int input)
{		
	REGS val;	
	__asm
	{
		mov eax,input
		cpuid		
		mov val.reg_eax,eax
		mov val.reg_ebx,ebx
		mov val.reg_ecx,ecx
		mov val.reg_edx,edx
	}	
	return val;
}

[gugoXX]

Ed ecco la parte C#. Non ho messo la lettura del counter della CPU perche' ho letto che sulle WMI dovrebbe essere proprio la frequenza istantanea, quindi va meglio la versione di ieri.

[DllImport("CPUID_DLL.dll")]
static extern REGS GetCPUID(uint eax);

// Classe di ritorno dal C++
struct REGS
{
    public int reg_eax;
    public int reg_ebx;
    public int reg_ecx;
    public int reg_edx;
}

// Classe per contenere le stringhe associate ad un registro
// E il metodo per restituire le interessate
public class REGSSplitted
{
    private string[] assoc;
    public REGSSplitted(string[] stampas)
    {
        assoc = stampas;
    }

    // E' la funzione chiave, stampa le stringhe relative alle feature
    // Il ritorno potrebbe anche essere string[], forse piu' chiaro
    // Ho messo l'enumerable, perche' meno si ritorna agli scalari
    // Meglio e' per i parallelismi futuri del PLINQ
    // Una funzione che ritorna un enumerable viene valutata
    // Effettivamente quanto serve (Lazy Evaluation)
    // In cascata, tutto insieme, e parallelizzato nel futuro PLINQ
    // Su core/processori separati.
    public IEnumerable<string> GetFromInt(int src)
    {                               
        // Spettacolo. Spero sia comprensibile                
        // Restutisco le stringhe che hanno il bit corrispondente ad 1
        var strs =
            from t in Enumerable.Range(0,32)
            where ( ( src & (1<<t)) !=0 )
            select assoc[t];
       
        return strs; 
    }
}

private static REGSSplitted ecxfeat1 = new REGSSplitted(
    new []{  
          "Streaming SIMD Extensions 3",
          "",
         ...
          "",
          "RAZ",             
    }
);


private static REGSSplitted edxfeat1 = new REGSSplitted(
    new []{   
      "Floating-point unit on-Chip",
      "Virtual Mode Extension",
     ...
      "IA64 Capabilities",
      "Pending Break Enable"
    }
);

// Restitusice la rappresentazione dei caratteri
// relativi ai byte di un intero
static string GetStringRepr(int val)
{
    // Prendo l'intero, lo converto in byte
    byte[] bytearr = BitConverter.GetBytes(val);
    // converto tutti i byte in caratteri
    char[] chararr = bytearr.Cast<char>().ToArray();
    // stringo
    string ret = new string(chararr);
    return ret;            
}

//Restituisce i primi 4 nibble di un intero.
static byte[] FromIntToNibbleOnly4(int intero)
{
    //Copiato da te.
    //Lasciato funzionale perche' elegante, anche se incasinato
    //L'ho scritto prima procedurale e faceva altrettanto schifo.
    //Lo faccio solo per 4 valori... gli altri si cestinano comunque :)
    var ogni4 = new[] { 0, 4, 8, 12 };
    var nibbles = ogni4.Select(t => (byte)((intero >> t) & 15));
    return nibbles.ToArray();             
}

//Stampo le 4 stringhe dei 4 registri in ordine.
//Funzionale mi sembra un po' esagerato.        
static void GetStringRepr(StringWriter sw,REGS complete)
{
    sw.Write(GetStringRepr(complete.reg_eax));
    sw.Write(GetStringRepr(complete.reg_ebx));
    sw.Write(GetStringRepr(complete.reg_ecx));
    sw.Write(GetStringRepr(complete.reg_edx));            
}

static void Main(string[] args)
{
    REGS zero = GetCPUID(0);
    Console.WriteLine("CPU Vendor: {0}{1}{2}", GetStringRepr(zero.reg_ebx), 
         GetStringRepr(zero.reg_edx), GetStringRepr(zero.reg_ecx));

    //Prendo le stringhe dei registri, e le unisco di volta in volta 
    StringWriter sw = new StringWriter();
    REGS due = GetCPUID(0x80000002);
    GetStringRepr(sw,due);

    REGS tre = GetCPUID(0x80000003);
    GetStringRepr(sw, tre);

    REGS quattro = GetCPUID(0x80000004);
    GetStringRepr(sw,quattro);
       
    Console.WriteLine("CPU Brand : {0}", sw.ToString());

    REGS uno = GetCPUID(1);
    byte[] vers = FromIntToNibbleOnly4(uno.reg_eax);

    // Qui non sono soddisfatto. Non so se riesco a far passare
    // come parametri diversi da stampare, quelli che e' il contenuto
    // dell'array.            
    Console.WriteLine(@"CPU Stepping: {0}, Model: {1}, Family: {2}, 
           Processor Type: {3}", vers[0], vers[1], vers[2], vers[3]);

    Console.WriteLine("");
    Console.WriteLine("Features");
    
    var stringhe = edxfeat1.GetFromInt(uno.reg_edx);
    stringhe=stringhe.Union(ecxfeat1.GetFromInt(uno.reg_ecx));

    //Stampo in versione funzionale. Eccessivo, ma solo per studio.
    stringhe.ToList().ForEach(t => Console.WriteLine(t));

    //Quella sopra e' la versione funzionale del codice seguente
    //foreach (string s in stringhe)
    //{
    //   Console.WriteLine(s);
    //}
    
    Console.ReadKey();
}

[gugoXX]

Il risultato

CPU Vendor: GenuineIntel
CPU Brand : Intel(R) Core(TM)2 CPU 6600 @ 2.40GHz
CPU Stepping: 6, Model: 15, Family: 6, Processor Type: 0

Features
Floating-point unit on-Chip
Virtual Mode Extension
Debugging Extension
Page Size Extension
Time-Stamp Counter
Model Specific Registers
Physical Address Extension
Machine Check Exception
CMPXCHG8 Instruction Supported
On-chip APIC Hardware Supported
Fast System Call
Memory Type Range Registers
Page Global Enable
Machine Check Architecture
Conditional Move Instruction Supported
Page Attribute Table
36-bit Page Size Extension
CLFLUSH Instruction supported
Debug Store
Thermal Monitor and Software Controlled Clock Facilities supported
Intel Architecture MMX technology supported
Fast floating point save and restore
Streaming SIMD Extensions supported
Streaming SIMD Extensions 2
Self-Snoop
Multi-Threading
Thermal Monitor supported
Pending Break Enable
Streaming SIMD Extensions 3
64-Bit Debug Store
MONITOR/MWAIT
CPL Qualified Debug Store
Virtual Machine Extensions
Enhanced Intel SpeedStep Technology
Thermal Monitor 2
Supplemental Streaming SIMD Extensions 3
CMPXCHG16B
Send Task Priority Messages
Performance Capabilities MSR

[Mazda RX8]

Originariamente inviato da cdimauro

Se:
- non devi scrivere un driver;
- il tuo scopo rimane esattamente quello che hai esposto qui http://www.hwupgrade.it/forum/showpo...&postcount=10;
- come programmazione sei più bianco di un lenzuolo e devi, quindi, imparare partendo dalle basi;

POTRESTI (metto il condizionale, altrimenti qui mi crocifiggono nuovamente, pur essendo in topic; vedi punto 2 qui sopra) prendere in seria considerazione Python (o IronPython se le classi della libreria standard .NET permettono di estrapolare TUTTE le informazioni che ti servono).

Originariamente inviato da dupa

io che sono un Javista e che quindi non sono nè un fan boy di Python nè di .NET ti consiglio di farlo in C#.

ciao

ecco qui, siamo sempre li, cosa fare?

PS Potrei aprire un sondaggio ke dice di votare il linguaggio più semplice da imparare da un nubbio completo come me...

[okay]

Originariamente inviato da Mazda RX8

ecco qui, siamo sempre li, cosa fare?

PS Potrei aprire un sondaggio ke dice di votare il linguaggio più semplice da imparare da un nubbio completo come me...

no... non ci siamo...

non dici cosa hai installato come tool e neppure ses hai digitato una qualche riga di codice... no non va bene.

Da come scrivi si potrebbe, come succede sempre, innescare un flame, e questo non va bene.

Devi capire che puoi iniziare anche con qbasic quando hai capito come funziona "il programmare" allora imparare altri linguaggi è una cosa semplicissima.

Non c'è il linguaggio migliore. Devi iniziare a usarne uno poi imparerai tutti gli altri e quello che ti conviene di + per ciò che intendi fare.

[Mazda RX8]

phyton sembra più facile...

[cionci]

Originariamente inviato da Mazda RX8

phyton sembra più facile...

Convinto te...secondo me nella curva di apprendimento c'è poca differenza fra Python e C#...