Конечная пикантная полезность компьютерной версии 4.0


Версия 4.0 моей программе! Возможно, вы помните мой грязный, старый код из здесь.

В любом случае, что эта программа делает несколько вещей:

  • Рассчитать ЦП и обработки графического процессора в Тфлопс (нынешний стандарт для измерения мощности в вычислениях)

  • Рассчитать общую вычислительную мощность в мой собственный оптимизированный блок результат, что факторы все в компьютере в уравнение.

  • Расчет общей расчетной мощностью нагрузки и рекомендует питание.

  • Рассчитать расходы на электроэнергию в течение долгого времени.

  • Некоторые другие вещи тоже.


from functools import partial

from termcolor import colored

magenta = partial(colored,
                  color='magenta')
cyan = partial(colored,
               color='cyan')
yellow = partial(colored,
                 color='yellow')


def run():
    pc_type = start()
    cpu_tdp, ram_type, cpu_score, cpu_avg_tflops = cpu(pc_type)
    ram_score, ram_tdp = ram(ram_type)
    gputdp, gpu_score, gpu_tflops = gpu(pc_type)
    drive_score, drive_type = drive1()
    hddtdp, ssdtdp = drive2(drive_score)
    bottleneck(pc_type=pc_type,
             cpu_score=cpu_score,
             drive_score=drive_score,
             drive_type=drive_type,
             gpu_score=gpu_score,
             ram_score=ram_score)
    total_tdp = final(pc_type=pc_type,
                      cpu_score=cpu_score,
                      cpu_tdp=cpu_tdp,
                      drive_score=drive_score,
                      gpu_score=gpu_score,
                      gputdp=gputdp,
                      hddtdp=hddtdp,
                      ram_score=ram_score,
                      ram_tdp=ram_tdp,
                      ssdtdp=ssdtdp,
                      cpu_avg_tflops=cpu_avg_tflops,
                      gpu_tflops=gpu_tflops)
    energy_cost_calc(total_tdp=total_tdp)
    again()
    thanks()


def start():
    print(colored("'." * 70,
                  color='white',
                  attrs=['blink']))
    print(magenta("* Welcome to Spicy's Ultimate Computer Utility *"))
    print(magenta("* Version Alpha 4.0 *"))
    print(magenta("** This program is still in alpha stage "
                  "and isn't perfect **"))
    print(magenta("If you are unsure about one of the questions, "
                  "look up the specs of the part on a website "
                  "like PCPartPicker or TechPowerUP"))
    print(magenta("** Make sure to pay attention to the units "
                  "specified in the questions. **"))
    print(magenta("** All results/scores are theoretical estimates. **"))
    return float(input(cyan("Is your system a laptop or desktop? "
                            "1 for laptop, 2 for desktop.")))


def cpu(pc_type):
    l1_factor = 100 #The smaller this is, the more L1 cache matters
    l3_factor = .3 #The larger this is, the more L3 cache matters
    name = input(cyan("What is the name of your processor?"))
    tdp = float(input(cyan(f"What is the TDP of the {name}? (in W)")))
    cores_count = float(input(cyan(f"How many cores does the {name} have?")))
    threads_count = float(input(cyan(f"How many threads "
                                     f"does the {name} have?")))
    l1_cache = float(input(cyan(f"How much L1 cache (in total) "
                                f"does the {name} have in KB?")))
    l2_cache = float(input(cyan(f"How much L2 cache (in total) "
                                f"does the {name} have in MB?")))
    l3_cache = float(input(cyan(f"How much L3 cache (in total) "
                                f"does the {name} have in MB?")))
    clock_speed = float(input(cyan(f"What is the clock speed (in GHz) "
                                   f"of the {name}?")))
    fabrication = float(input(cyan(f"What is the fabrication process "
                                   f"of the {name} in nm?")))
    ram_type = float(input(cyan(f"What type of RAM does the {name} use? "
                                f"Enter 3 for DDR3, 4 for DDR4, etc.")))
    score = ((cores_count + threads_count + clock_speed + ram_type + l2_cache
              + (l1_cache / l1_factor) + (l3_factor * l3_cache))
             / fabrication) * pc_type
    cpu_sp_gflops = ((((cores_count+threads_count)/2)*(clock_speed*1000000000))*8)/1000000000
    cpu_dp_gflops = ((((cores_count+threads_count)/2)*(clock_speed*1000000000))*4)/1000000000
    #the 2 is for the average of cores and threads
    #the first 1000000000 is to convert GHz to Hz
    #the second 1000000000 is to convert FLOPS to GFLOPS
    #the 8 is for 8 single precision floating point operations per cycle
    #the 4 is for 4 double precision floating point operations per cycle
    print(yellow(f"** The {name} has a score of {round(score, 5)}. **"))
    print(yellow(f"** The {name} is capable of {round(cpu_sp_gflops, 2)} single precision GFLOPS. **"))
    print(yellow(f"** The {name} is capable of {round(cpu_dp_gflops, 2)} double precision GFLOPS. **"))
    cpu_avg_tflops = ((cpu_sp_gflops+cpu_dp_gflops)/2)/1000
    return tdp, ram_type, score, cpu_avg_tflops


def ram(ram_type):
    ram_tdp_factor = 4 #1 RAM stick draws around 4W
    dimm_speed_factor = 500 #The smaller this is, the more speed matters
    ram_equation_factor = 150 #The smaller this is, the less RAM score matters overall
    amount = float(input(cyan("How much RAM does your system have "
                              "(in GB?)")))
    slowest_dimm_speed = float(input(cyan("What is the speed of your slowest "
                                          "installed DIMM? (in MHz)")))
    dimms_count = (float(input(cyan("How many DIMMs do you have installed?")))
                   * ram_tdp_factor)
    score = ((ram_type + (slowest_dimm_speed / dimm_speed_factor)) * amount) / ram_equation_factor
    print(yellow(f"** Your RAM has a score of {round(score, 5)}. **"))
    return score, dimms_count


def gpu(pc_type):
    name = input(cyan("What is the name of your GPU?"))
    memory_type = int(input(cyan(f"What type of memory does the {name} use? "
                                 f"0 for GDDR, 1 for HBM")))
    tdp = float(input(cyan(f"What is the TDP of the {name}? (in W)")))

    if memory_type == 0:
        cores_factor = 400 #The smaller this is, the more cores matter
        tmus_factor = 25 #the smaller this is, the more TMUs matter
        rops_factor = 10 #the smaller this is, the more ROPs matter
        memsize_factor = 1000 #the smaller this is, the more VRAM amount matters
        buswidth_factor = 30 #the smaller this is, the more bus width matters
        clockspeed_factor = 2 #the larger this is, the more clockspeed matters
        memspeed_factor = 1000 #the smaller this is, the more VRAM speed matters
        gpu_equation_factor = 25 #the smaller this is, the more GPU score matters overall
        cores_count = float(input(cyan(f"How many cores "
                                       f"does the {name} have?")))
        tmus_count = float(input(cyan(f"How many TMUs "
                                      f"does the {name} have?")))
        rops_count = float(input(cyan(f"How many ROPs "
                                      f"does the {name} have?")))
        memory_size = float(input(cyan(f"How much memory (in MB) "
                                       f"does the {name} have?")))
        memory_type = float(input(cyan(f"What type of memory "
                                       f"does the {name} have? "
                                       f"Enter 3 for GDDR3, 5 for GDDR5, "
                                       f"and 8 for GDDR5X.")))
        # GDDR5X is 8 to account for its additional data rate
        bus_width = float(input(cyan(f"What is the bus width "
                                     f"of the {name}?")))
        clock_speed = float(input(cyan(f"What is the clock speed "
                                       f"of the {name} in GHz?")))
        memory_speed = float(input(cyan(f"What is the effective memory speed "
                                        f"of the {name} in MHz?")))
        fabrication = float(input(cyan(f"What is the fabrication process "
                                       f"of the {name} in nm?")))
        score = ((((cores_count / cores_factor) + (tmus_count / tmus_factor) + (rops_count / rops_factor)
                   + (memory_size / memsize_factor) + (bus_width / buswidth_factor)
                   + (clock_speed * clockspeed_factor) + (memory_speed / memspeed_factor))
                  * ((memory_type / fabrication) / gpu_equation_factor))) * pc_type


    if memory_type == 1:
        cores_factor = 400 #The smaller this is, the more cores matter
        tmus_factor = 25 #the smaller this is, the more TMUs matter
        rops_factor = 10 #the smaller this is, the more ROPs matter
        memsize_factor = 1000 #the smaller this is, the more VRAM amount matters
        buswidth_factor = 250 #the smaller this is, the more bus width matters
        clockspeed_factor = 2 #the larger this is, the more clockspeed matters
        memspeed_factor = 150 #the smaller this is, the more VRAM speed matters
        gpu_equation_factor = 25 #the smaller this is, the more GPU score matters overall
        memtypfabcombo_factor = 3 #the larger this is, the more memory type/fabrication matters
        cores_count = float(input(cyan(f"How many cores "
                                       f"does the {name} have?")))
        tmus_count = float(input(cyan(f"How many TMUs "
                                      f"does the {name} have?")))
        rops_count = float(input(cyan(f"How many ROPs "
                                      f"does the {name} have?")))
        memory_size = float(input(cyan(f"How much memory (in MB) "
                                       f"does the {name} have?")))
        memory_type = float(input(cyan(f"What type of memory "
                                       f"does the {name} have? "
                                       f"Enter 1 for HBM, 2 for HBM2, etc.")))
        bus_width = float(input(cyan(f"What is the bus width "
                                     f"of the {name}?")))
        clock_speed = float(input(cyan(f"What is the clock speed "
                                       f"of the {name} in GHz?")))
        memory_speed = float(input(cyan(f"What is the effective memory speed "
                                        f"of the {name} in MHz?")))
        fabrication = float(input(cyan(f"What is the fabrication process "
                                       f"of the {name} in nm?")))
        score = (((cores_count / cores_factor) + (tmus_count / tmus_factor) + (rops_count / rops_factor)
                  + (memory_size / memsize_factor) + (bus_width / buswidth_factor)
                  + (clock_speed * clockspeed_factor) + (memory_speed / memspeed_factor))
                 * ((((memory_type / fabrication))*memtypfabcombo_factor) / gpu_equation_factor)) * pc_type
    gpu_tflops = ((rops_count * 4 * 16) * clock_speed)/1000 
    #The 4 is for each compute unit (ROP) has 4 SIMD execution units
    #The 16 is for each SIMD unit, which is 16 ALUs wide per unit
    #The 1000 is to convert GFLOPS to TFLOPS
    print(yellow(f"** The {name} has a score of {round(score, 5)}. **"))
    print(yellow(f"** The {name} is capable of {round(gpu_tflops, 2)} TFLOPS. **"))

    return tdp, score, gpu_tflops


def drive1():
    drive_equation_factor = 30 #the smaller this is, the more drive score matters overall
    drive_type = float(input(cyan("Is your boot drive an HDD or SSD? "
                                  "Enter 1 for HDD, 2 for SSD.")))
    drive_interface = float(input(cyan("What interface does your boot drive use? "
        "1 for SATA, 2 for IDE/PATA.")))
    #need to implement this
    if drive_type == 1:
        rpm_factor = 1000 #the smaller this is, the more HDD RPM matters
        hdd_rpm = float(input(cyan("What is the RPM of your HDD?")))
        hdd_cache = float(input(cyan("How much buffer cache (in MB) does your HDD have?")))
        hdd_cache_factor = 25 #the larger this is, the more HDD buffer cache size matters
        drive_free = float(input(cyan("How much storage is available "
                                      "(not filled) on your boot drive "
                                      "(in GB)")))
        drive_total = float(input(cyan("What is the total amount of storage "
                                       "on your boot drive (in GB)")))
        percent_free = (drive_free / drive_total) * 100
        print(yellow(f"* Your boot drive is "
                     f"{round(percent_free, 3)}% free. *"))
        drive_score = ((((1 / percent_free) * 100) * (hdd_rpm + (hdd_cache * hdd_cache_factor) / rpm_factor)) / drive_equation_factor) / drive_interface
    if drive_type == 2:
        ssd_factor = 5 #the larger this is, the more drive score will increase if SSD is boot drive
        drive_free = float(input(cyan(f"How much storage is available "
                                      f"(not filled) on your boot drive "
                                      f"(in GB)")))
        drive_total = float(input(cyan("What is the total amount of storage "
                                       "on your boot drive (in GB)")))
        percent_free = (drive_free / drive_total) * 100
        print(yellow(f"* Your boot drive is "
                     f"{round(percent_free, 3)}% free. *"))
        drive_score = (((((1 / percent_free) * 100) * ssd_factor) * drive_type) 
            / drive_equation_factor) / drive_interface

    return drive_score, drive_type


def drive2(drive_score):
    ssdtdp = float(input(cyan("How many SSDs do you have "
                              "installed in your system?")))
    ssdtdp *= 3.25  # 1 SSD draws this much watts (the *= thing means ssdtdp = ssdtdp*3.25)
    hddtdp = float(input(cyan(f"How many HDDs do you have "
                              f"installed in your system?")))
    hddtdp *= 8  # 1 HDD draws this much watts
    print(yellow(f"** Your boot drive's score is "
                  f"{round(drive_score, 5)}. **"))
    return hddtdp, ssdtdp


def final(pc_type,
          cpu_score,
          gpu_score,
          drive_score,
          ram_score,
          cpu_tdp,
          gputdp,
          ram_tdp,
          hddtdp,
          ssdtdp,
          gpu_tflops,
          cpu_avg_tflops):
    cpu_gpu_tdp_factor = 0.8 #the larger this is, the more to remove from CPU and GPU TDP 
                             #(because they don't reach full spec)

    mainboard_tdp = input(cyan("Does your mainboard support overclocking? "
                              "(Y/N)"))

    if mainboard_tdp == "N":
        mainboard_tdp = 32.5

    if mainboard_tdp == "Y":
        mainboard_tdp = 62.5

    if pc_type == 2:
        wifi_tdp = input(cyan("Do you have a wireless adapter installed?"
                              "(Y/N)"))
        sc_tdp = input(cyan("Do you have a sound card installed? (Y/N)"))

        if wifi_tdp == "Y":
            wifi_tdp = 2

        if wifi_tdp == "N":
            wifi_tdp = 0

        if sc_tdp == "Y":
            sc_tdp = 10

        if sc_tdp == "N":
            sc_tdp = 0

    if pc_type == 1:
        wifi_tdp = 1
        sc_tdp = 3
        # both of these are assumptions, I have no idea how much W laptop WiFi cards or sound cards use
    final_score = (cpu_score + gpu_score + drive_score + ram_score)
    final_tflops = cpu_avg_tflops+gpu_tflops
    dvdtdp = float(input(cyan("How many optical drives "
                              "do you have installed?")))
    # 1 ODD draws around 20 watts, I'm assuming laptop ODDs use half of that.
    #need to implement support for laptops without ODD
    dvdtdp = dvdtdp * 10 * pc_type

    if pc_type == 2:
        fantdp = float(input(cyan("How many case fans do you have installed? "
                                  "(counting CPU cooler)")))
        fantdp *= 4  # 1 120mm fan draws around 4 watts

    if pc_type == 1:
        fantdp = 0.5 #I will assume that laptops' cooling solutions use 0.5 watts total

    usbtdp = float(input(cyan("How many USB ports does your computer have? "
                              "(in total)")))
    usbtdp *= 5  # USB 3.0 can pull 5W
    # Estimated max load TDP equation
    total_tdp = (((cpu_tdp + gputdp) * cpu_gpu_tdp_factor) + ram_tdp + hddtdp + ssdtdp
                 + dvdtdp + fantdp + usbtdp + sc_tdp + wifi_tdp) + mainboard_tdp
    # max spec TDP equation
    psu_factor = 50 #The larger this is, the more "extra" watts to recommend for the PSU 
                    #since a PSU should never reach full spec
    recommended_psu = (cpu_tdp + gputdp + ram_tdp + hddtdp + ssdtdp + dvdtdp + fantdp
                       + usbtdp + mainboard_tdp + wifi_tdp + sc_tdp + psu_factor)
    print(magenta("Calculating final score..."))
    print(yellow("** Your final score is... **"))
    print(round(final_score, 5))
    print(yellow(f"** Your system is capable of {final_tflops} TFLOPS. **"))
    print(yellow("** Your predicted maximum load wattage is... **"))
    print(f"{round(total_tdp, 1)} Watts")
    print(yellow(f"** I would recommend using a power supply of at least "
                 f"{int(round(recommended_psu, -1))} watts. **"))
    return total_tdp


def energy_cost_calc(total_tdp):
    hrscalc = input(cyan("Would you also like to factor in "
                         "your energy costs? Y/N"))
    if hrscalc == "Y":
        hrs = float(input(cyan("On average, how many hours do you use "
                               "your computer daily?")))
        price = float(input(cyan("What is the price per kWh "
                                 "where you live? (in dollars)")))
        ktdp = total_tdp / 1000  # TDP in kW
        dailycost = hrs * price * ktdp
        hourcost = dailycost / 24
        weeklycost = dailycost * 7
        monthlycost = dailycost * 30.42 #an average month has 30.42 days
        yearlycost = dailycost * 365
        print(yellow(f"Your cost is ${round(hourcost, 2)} per hour, "
                     f"${round(dailycost, 2)} per day, "
                     f"${round(weeklycost, 2)} per week, "
                     f"${round(monthlycost, 2)} per month, "
                     f"and ${round(yearlycost, 2)} per year."))


def bottleneck(pc_type,
             gpu_score,
             ram_score,
             drive_score,
             cpu_score,
             drive_type):
    print(yellow("Calculating bottleneck..."))
    bram_factor = 4
    bdrive_factor = 5
    if pc_type == 1:  # laptop
        bgpu_factor = 3.5
        bcpu_factor = 2
        bgpus = gpu_score * bgpu_factor
        brams = ram_score * bram_factor
        bhds = drive_score * bdrive_factor
        bcpus = cpu_score * bcpu_factor

    if pc_type == 2:  # desktop
        bgpu_factor = 1.75
        bgpus = gpu_score * bgpu_factor
        brams = ram_score * bram_factor
        bhds = drive_score * bdrive_factor
        bcpus = cpu_score

    if bgpus <= brams and bgpus <= bhds and bgpus <= bcpus:
        gpub = 1
        cpub = 0
        ramb = 0
        hdb = 0
    if bcpus <= brams and bcpus <= bhds and bcpus <= bgpus:
        cpub = 1
        gpub = 0
        ramb = 0
        hdb = 0
    if brams <= bcpus and brams <= bhds and brams <= bgpus:
        ramb = 1
        cpub = 0
        gpub = 0
        hdb = 0
    if bhds <= brams and bhds <= bcpus and bhds <= bgpus:
        hdb = 1
        cpub = 0
        ramb = 0
        gpub = 0
    if gpub == 1:
        print(yellow("Your GPU is the bottleneck in your system."))
        print(yellow("You could improve your GPU score "
                     "by overclocking or replacing your GPU."))

    if cpub == 1:
        print(yellow("Your CPU is the bottleneck in your system."))
        print(yellow("You could improve your CPU score "
                     "by overclocking or replacing your CPU."))

    if ramb == 1:
        print(yellow("Your RAM is the bottleneck in your system."))
        print(yellow("You could improve your RAM score "
                     "by overclocking, replacing, "
                     "or installing more or faster RAM."))

    if hdb == 1:
        print(yellow("Your boot disk is the bottleneck in your system."))

        if drive_type == 1:
            print(yellow("You could improve your boot disk score "
                         "by replacing your HDD with a faster HDD or an SSD, "
                         "or by freeing up space."))

        if drive_type == 2:
            print(yellow("You could improve your boot disk score "
                         "by freeing up space."))


def thanks():
    print(magenta("Thank you for using Spicy's Ultimate Computer Utility!"))
    print(colored("Copyright NFR 2018",
                  color='green'))


def again():
    again = input(cyan("Do you want to use the calculator again? Y/N"))
    if again == 'Y':
        start()

if __name__ == '__main__':
    run()
else:
    run()


Комментарии
2 ответа


def again():
again = input(cyan("Do you want to use the calculator again? Y/N"))
if again == 'Y':
start()

Вы, вероятно, хотел позвонить run() а не start()потому что этот код не делает программу повторить, как и предполагалось.

Но что еще более важно, функции не должны рассматриваться в качестве меток goto! Звоню start() или run() поэтому нецелесообразно. Ответ "Г" приведет к ненужному углублению стека вызовов. Если программа может петли, то вы должны написать его как цикл:

def again():
return 'Y' == input(cyan("Do you want to use the calculator again? Y/N"))

def main():
while True:
run()
if not again():
break
thanks()



if __name__ == '__main__':
run()
else:
run()

В else блок побеждает целую цель if __name__ == '__main__' тест.

7
ответ дан 9 марта 2018 в 04:03 Источник Поделиться

Вместо длинной серии if блоки, чтобы выяснить узкое место, почему бы не использовать min?

if bgpus <= brams and bgpus <= bhds and bgpus <= bcpus:
gpub = 1
cpub = 0
ramb = 0
hdb = 0
if bcpus <= brams and bcpus <= bhds and bcpus <= bgpus:
cpub = 1
gpub = 0
ramb = 0
hdb = 0
if brams <= bcpus and brams <= bhds and brams <= bgpus:
ramb = 1
cpub = 0
gpub = 0
hdb = 0
if bhds <= brams and bhds <= bcpus and bhds <= bgpus:
hdb = 1
cpub = 0
ramb = 0
gpub = 0

становится:

bottleneck = min(bhds, brams, bcpus, bgpus)
if bhds == bottleneck:
...


if pc_type == 2:
wifi_tdp = input(cyan("Do you have a wireless adapter installed?"
"(Y/N)"))
sc_tdp = input(cyan("Do you have a sound card installed? (Y/N)"))

if wifi_tdp == "Y":
wifi_tdp = 2

if wifi_tdp == "N":
wifi_tdp = 0

каждый тип boolean вопрос, ответ вы хотите быть Y и N. Я ненавижу того, чтобы набрать в верхнем регистре, и, как правило, просто нажмите Enter (который по умолчанию предполагается y для меня apt install и т. д.). Вы можете изменить его на

input_value in 'yY'  # or in 'nN'`


Я запустил программу с моим системных требований, а ближе к концу, в final; я получил:

Does your mainboard support overclocking? (Y/N)y
Do you have a wireless adapter installed?(Y/N)n
Do you have a sound card installed? (Y/N)y
How many optical drives do you have installed?0
How many case fans do you have installed? (counting CPU cooler)7
How many USB ports does your computer have? (in total)12
Traceback (most recent call last):
File "189181.py", line 436, in <module>
run()
File "189181.py", line 37, in run
gpu_tflops=gpu_tflops)
File "189181.py", line 313, in final
+ dvdtdp + fantdp + usbtdp + sc_tdp + wifi_tdp) + mainboard_tdp
TypeError: unsupported operand type(s) for +: 'float' and 'str'


Вы можете абстрактного пользователя-вход в отдельную функцию:

def get_input(prompt, value_type=float, strict=True):
prompt = cyan(prompt + '> ')
while True:
value = input(prompt)
try:
value = value_type(value)
return value
except ValueError as e:
if strict is True:
continue
raise e # is not strict

который будет постоянно запрашивать пользователя для входа (если strict это True) до тех пор, пока входной тип является допустимым.

2
ответ дан 10 марта 2018 в 01:03 Источник Поделиться