← Back to branch summary

~ubuntu-branches/ubuntu/vivid/slurm-llnl/vivid

« back to all changes in this revision

Viewing changes to src/sreport/cluster_reports.c

  • Committer: Bazaar Package Importer
  • Author(s): Gennaro Oliva
  • Date: 2009-09-24 23:28:15 UTC
  • mfrom: (1.1.11 upstream) (3.2.4 sid)
  • Revision ID: james.westby@ubuntu.com-20090924232815-enh65jn32q1ebg07
Tags: 2.0.5-1
http://bugs.debian.org/541252
* New upstream release 
* Changed dependecy from lib-mysqlclient15 to lib-mysqlclient 
* Added Default-Start for runlevel 2 and 4 and $remote_fs requirement in
  init.d scripts (Closes: #541252)
* Postinst checks for wrong runlevels 2 and 4 links
* Upgraded to standard version 3.8.3
* Add lintian overrides for missing slurm-llnl-configurator.html in doc
  base registration
* modified postrm scripts to ignore pkill return value in order to avoid
  postrm failure when no slurm process is running
* Checking for slurmctld.pid before cancelling running and pending
  jobs during package removal 

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/sreport/cluster_reports.c
6
6
 *  Copyright (C) 2008 Lawrence Livermore National Security.
7
7
 *  Produced at Lawrence Livermore National Laboratory (cf, DISCLAIMER).
8
8
 *  Written by Danny Auble <da@llnl.gov>
9
 
 *  LLNL-CODE-402394.
 
9
 *  CODE-OCEC-09-009. All rights reserved.
10
10
 *  
11
11
 *  This file is part of SLURM, a resource management program.
12
 
 *  For details, see <http://www.llnl.gov/linux/slurm/>.
 
12
 *  For details, see <https://computing.llnl.gov/linux/slurm/>.
 
13
 *  Please also read the included file: DISCLAIMER.
13
14
 *  
14
15
 *  SLURM is free software; you can redistribute it and/or modify it under
15
16
 *  the terms of the GNU General Public License as published by the Free
46
47
        PRINT_CLUSTER_ACPU,
47
48
        PRINT_CLUSTER_DCPU,
48
49
        PRINT_CLUSTER_ICPU,
 
50
        PRINT_CLUSTER_PDCPU,
49
51
        PRINT_CLUSTER_OCPU,
50
52
        PRINT_CLUSTER_RCPU,
51
53
        PRINT_CLUSTER_TOTAL,
390
392
                        field->type = PRINT_CLUSTER_ACCT;
391
393
                        field->name = xstrdup("Account");
392
394
                        if(tree_display)
393
 
                                field->len = 20;
 
395
                                field->len = -20;
394
396
                        else
395
397
                                field->len = 15;
396
398
                        field->print_routine = print_fields_str;
411
413
                        field->name = xstrdup("Cluster");
412
414
                        field->len = 9;
413
415
                        field->print_routine = print_fields_str;
414
 
                } else if(!strncasecmp("cpu_count", object, 
 
416
                } else if(!strncasecmp("cpucount", object, 
415
417
                                       MAX(command_len, 2))) {
416
418
                        field->type = PRINT_CLUSTER_CPUS;
417
419
                        field->name = xstrdup("CPU count");
453
455
                        else
454
456
                                field->len = 9;
455
457
                        field->print_routine = sreport_print_time;
456
 
                } else if(!strncasecmp("Proper", object, MAX(command_len, 1))) {
 
458
                } else if(!strncasecmp("PlannedDown", object,
 
459
                                       MAX(command_len, 2))) {
 
460
                        field->type = PRINT_CLUSTER_PDCPU;
 
461
                        field->name = xstrdup("PLND Down");
 
462
                        if(time_format == SREPORT_TIME_SECS_PER
 
463
                           || time_format == SREPORT_TIME_MINS_PER
 
464
                           || time_format == SREPORT_TIME_HOURS_PER)
 
465
                                field->len = 18;
 
466
                        else
 
467
                                field->len = 10;
 
468
                        field->print_routine = sreport_print_time;
 
469
                } else if(!strncasecmp("Proper", object, MAX(command_len, 2))) {
457
470
                        field->type = PRINT_CLUSTER_USER_PROPER;
458
471
                        field->name = xstrdup("Proper Name");
459
472
                        field->len = 15;
505
518
                        continue;
506
519
                }
507
520
 
508
 
                if(newlen > 0) 
 
521
                if(newlen) 
509
522
                        field->len = newlen;
510
523
                
511
524
                list_append(print_fields_list, field);          
550
563
                       "----------------------------------------\n");
551
564
                printf("%s %s - %s (%d*cpus secs)\n", 
552
565
                       report_name, start_char, end_char, 
553
 
                       (cluster_cond->usage_end - cluster_cond->usage_start));
 
566
                       (int)(cluster_cond->usage_end
 
567
                             - cluster_cond->usage_start));
554
568
                switch(time_format) {
555
569
                case SREPORT_TIME_PERCENT:
556
570
                        printf("Time reported in %s\n", time_format_string);
596
610
 
597
611
        print_fields_list = list_create(destroy_print_field);
598
612
 
599
 
        bzero(&cluster_cond, sizeof(acct_cluster_cond_t));
 
613
        memset(&cluster_cond, 0, sizeof(acct_cluster_cond_t));
600
614
 
601
615
        assoc_cond->with_sub_accts = 1;
602
616
 
603
617
        _set_assoc_cond(&i, argc, argv, assoc_cond, format_list);
604
618
 
605
619
        if(!list_count(format_list)) 
606
 
                slurm_addto_char_list(format_list, "Cluster,Ac,L,P,Used");
 
620
                slurm_addto_char_list(format_list, 
 
621
                                      "Cluster,Ac,Login,Proper,Used");
607
622
 
608
623
        _setup_print_fields_list(format_list);
609
624
        list_destroy(format_list);
723
738
                       "----------------------------------------\n");
724
739
                printf("Cluster/Account/User Utilization %s - %s (%d secs)\n", 
725
740
                       start_char, end_char, 
726
 
                       (assoc_cond->usage_end - assoc_cond->usage_start));
 
741
                       (int)(assoc_cond->usage_end - assoc_cond->usage_start));
727
742
                
728
743
                switch(time_format) {
729
744
                case SREPORT_TIME_PERCENT:
782
797
                                                print_acct = get_tree_acct_name(
783
798
                                                        local_acct,
784
799
                                                        parent_acct,
785
 
                                                        sreport_cluster->name,
786
800
                                                        tree_list);
787
801
                                                xfree(local_acct);
788
802
                                        } else {
900
914
 
901
915
        print_fields_list = list_create(destroy_print_field);
902
916
 
903
 
        bzero(&cluster_cond, sizeof(acct_cluster_cond_t));
 
917
        memset(&cluster_cond, 0, sizeof(acct_cluster_cond_t));
904
918
 
905
919
        _set_assoc_cond(&i, argc, argv, assoc_cond, format_list);
906
920
 
907
921
        if(!list_count(format_list)) 
908
 
                slurm_addto_char_list(format_list, "Cluster,L,P,Ac,Used");
 
922
                slurm_addto_char_list(format_list,
 
923
                                      "Cluster,Login,Proper,Ac,Used");
909
924
 
910
925
        _setup_print_fields_list(format_list);
911
926
        list_destroy(format_list);
1047
1062
                       "----------------------------------------\n");
1048
1063
                printf("Cluster/User/Account Utilization %s - %s (%d secs)\n", 
1049
1064
                       start_char, end_char, 
1050
 
                       (assoc_cond->usage_end - assoc_cond->usage_start));
 
1065
                       (int)(assoc_cond->usage_end - assoc_cond->usage_start));
1051
1066
                
1052
1067
                switch(time_format) {
1053
1068
                case SREPORT_TIME_PERCENT:
1186
1201
 
1187
1202
        print_fields_list = list_create(destroy_print_field);
1188
1203
 
1189
 
        bzero(&cluster_cond, sizeof(acct_cluster_cond_t));
 
1204
        memset(&cluster_cond, 0, sizeof(acct_cluster_cond_t));
1190
1205
 
1191
1206
        _set_wckey_cond(&i, argc, argv, wckey_cond, format_list);
1192
1207
 
1193
1208
        if(!list_count(format_list)) 
1194
 
                slurm_addto_char_list(format_list, "Cluster,L,P,WCkey,Used");
 
1209
                slurm_addto_char_list(format_list, 
 
1210
                                      "Cluster,Login,Proper,WCkey,Used");
1195
1211
 
1196
1212
        _setup_print_fields_list(format_list);
1197
1213
        list_destroy(format_list);
1315
1331
                       "----------------------------------------\n");
1316
1332
                printf("Cluster/User/WCKey Utilization %s - %s (%d secs)\n", 
1317
1333
                       start_char, end_char, 
1318
 
                       (wckey_cond->usage_end - wckey_cond->usage_start));
 
1334
                       (int)(wckey_cond->usage_end - wckey_cond->usage_start));
1319
1335
                
1320
1336
                switch(time_format) {
1321
1337
                case SREPORT_TIME_PERCENT:
1455
1471
                goto end_it;
1456
1472
 
1457
1473
        if(!list_count(format_list)) 
1458
 
                slurm_addto_char_list(format_list, "Cl,al,d,i,res,rep");
 
1474
                slurm_addto_char_list(format_list, "Cl,al,d,planned,i,res,rep");
1459
1475
 
1460
1476
        _setup_print_fields_list(format_list);
1461
1477
        list_destroy(format_list);
1484
1500
                while((accting = list_next(itr3))) {
1485
1501
                        total_acct.alloc_secs += accting->alloc_secs;
1486
1502
                        total_acct.down_secs += accting->down_secs;
 
1503
                        total_acct.pdown_secs += accting->pdown_secs;
1487
1504
                        total_acct.idle_secs += accting->idle_secs;
1488
1505
                        total_acct.resv_secs += accting->resv_secs;
1489
1506
                        total_acct.over_secs += accting->over_secs;
1496
1513
                local_total_time =
1497
1514
                        (uint64_t)total_time * (uint64_t)total_acct.cpu_count;
1498
1515
                total_reported = total_acct.alloc_secs + total_acct.down_secs 
1499
 
                        + total_acct.idle_secs + total_acct.resv_secs;
 
1516
                        + total_acct.pdown_secs + total_acct.idle_secs
 
1517
                        + total_acct.resv_secs;
1500
1518
 
1501
1519
                while((field = list_next(itr2))) {
1502
1520
                        switch(field->type) {
1547
1565
                                                     (curr_inx == 
1548
1566
                                                      field_count));
1549
1567
                                break;
 
1568
                        case PRINT_CLUSTER_PDCPU:
 
1569
                                        field->print_routine(field,
 
1570
                                                     total_acct.pdown_secs,
 
1571
                                                     total_reported,
 
1572
                                                     (curr_inx == 
 
1573
                                                      field_count));
 
1574
                                break;
1550
1575
                        case PRINT_CLUSTER_TOTAL:
1551
1576
                                field->print_routine(field,
1552
1577
                                                     total_reported,
1605
1630
        sreport_cluster_rec_t *sreport_cluster = NULL;
1606
1631
        print_field_t *field = NULL;
1607
1632
        int field_count = 0;
1608
 
        char *print_acct = NULL;
1609
1633
 
1610
1634
        print_fields_list = list_create(destroy_print_field);
1611
1635
 
1614
1638
        _set_wckey_cond(&i, argc, argv, wckey_cond, format_list);
1615
1639
 
1616
1640
        if(!list_count(format_list)) 
1617
 
                slurm_addto_char_list(format_list, "Cluster,WCKey,L,P,Used");
 
1641
                slurm_addto_char_list(format_list, 
 
1642
                                      "Cluster,WCKey,Login,Proper,Used");
1618
1643
 
1619
1644
        _setup_print_fields_list(format_list);
1620
1645
        list_destroy(format_list);
1748
1773
                       "----------------------------------------\n");
1749
1774
                printf("Cluster/WCKey/User Utilization %s - %s (%d secs)\n", 
1750
1775
                       start_char, end_char, 
1751
 
                       (wckey_cond->usage_end - wckey_cond->usage_start));
 
1776
                       (int)(wckey_cond->usage_end - wckey_cond->usage_start));
1752
1777
                
1753
1778
                switch(time_format) {
1754
1779
                case SREPORT_TIME_PERCENT:
1788
1813
                                struct passwd *pwd = NULL;
1789
1814
                                switch(field->type) {
1790
1815
                                case PRINT_CLUSTER_WCKEY:
1791
 
                                        if(tree_display) {
1792
 
                                                char *local_acct = NULL;
1793
 
                                                char *parent_acct = NULL;
1794
 
                                                if(sreport_assoc->user) {
1795
 
                                                        local_acct =
1796
 
                                                                xstrdup_printf(
1797
 
                                                                        "|%s", 
1798
 
                                                                        sreport_assoc->acct);
1799
 
                                                        parent_acct =
1800
 
                                                                sreport_assoc->acct;
1801
 
                                                } else {
1802
 
                                                        local_acct = xstrdup(
1803
 
                                                                sreport_assoc->acct);
1804
 
                                                        parent_acct = sreport_assoc->
1805
 
                                                                parent_acct;
1806
 
                                                }
1807
 
                                                print_acct = get_tree_acct_name(
1808
 
                                                        local_acct,
1809
 
                                                        parent_acct,
1810
 
                                                        sreport_cluster->name,
1811
 
                                                        tree_list);
1812
 
                                                xfree(local_acct);
1813
 
                                        } else {
1814
 
                                                print_acct =
1815
 
                                                        sreport_assoc->acct;
1816
 
                                        }
1817
1816
                                        field->print_routine(
1818
1817
                                                field, 
1819
 
                                                print_acct,
 
1818
                                                sreport_assoc->acct,
1820
1819
                                                (curr_inx == field_count));
1821
1820
                                        
1822
1821
                                        break;