[0001]
[0002]
[0003]
[0004]
[0005]
[0006]
[0007]
[0008]
[0009]
[0010]
[0011]
[0012]
[0013]
[0014]
[0015]
[0016]
[0017]
[0018]
[0019]
[0020]
[0021]
[0022]
[0023]
[0024]
[0025]
[0026]
[0027]
[0028]
[0029]
[0030]
[0031]
[0032]
[0033]
[0034]
[0035]
[0036]
[0037]
[0038]
[0039]
[0040]
[0041]
[0042]
[0043]
[0044]
[0045]
[0046]
[0047]
[0048]
[0049]
[0050]
[0051]
[0052]
[0053]
[0054]
[0055]
[0056]
[0057]
[0058]
[0059]
[0060]
[0061]
[0062]
[0063]
[0064]
[0065]
[0066]
[0067]
[0068]
[0069]
[0070]
[0071]
[0072]
[0073]
[0074]
[0075]
[0076]
[0077]
[0078]
[0079]
[0080]
[0081]
[0082]
[0083]
[0084]
[0085]
[0086]
[0087]
[0088]
[0089]
[0090]
[0091]
[0092]
[0093]
[0094]
[0095]
[0096]
[0097]
[0098]
[0099]
[0100]
[0101]
[0102]
[0103]
[0104]
[0105]
[0106]
[0107]
[0108]
[0109]
[0110]
[0111]
[0112]
[0113]
[0114]
[0115]
[0116]
[0117]
[0118]
[0119]
[0120]
[0121]
[0122]
[0123]
[0124]
[0125]
[0126]
[0127]
[0128]
[0129]
[0130]
[0131]
[0132]
[0133]
[0134]
[0135]
[0136]
[0137]
[0138]
[0139]
[0140]
[0141]
[0142]
[0143]
[0144]
[0145]
[0146]
[0147]
[0148]
[0149]
[0150]
[0151]
[0152]
[0153]
[0154]
[0155]
[0156]
[0157]
[0158]
[0159]
[0160]
[0161]
[0162]
[0163]
[0164]
[0165]
[0166]
[0167]
[0168]
[0169]
[0170]
[0171]
[0172]
[0173]
[0174]
[0175]
[0176]
[0177]
[0178]
[0179]
[0180]
[0181]
[0182]
[0183]
[0184]
[0185]
[0186]
[0187]
[0188]
[0189]
[0190]
[0191]
[0192]
[0193]
[0194]
[0195]
[0196]
[0197]
[0198]
[0199]
[0200]
[0201]
[0202]
[0203]
[0204]
[0205]
[0206]
[0207]
[0208]
[0209]
[0210]
[0211]
[0212]
[0213]
[0214]
[0215]
[0216]
[0217]
[0218]
[0219]
[0220]
[0221]
[0222]
[0223]
[0224]
[0225]
[0226]
[0227]
[0228]
[0229]
[0230]
[0231]
[0232]
[0233]
[0234]
[0235]
[0236]
[0237]
[0238]
[0239]
[0240]
[0241]
[0242]
[0243]
[0244]
[0245]
[0246]
[0247]
[0248]
[0249]
[0250]
[0251]
[0252]
[0253]
[0254]
[0255]
[0256]
[0257]
[0258]
[0259]
[0260]
[0261]
[0262]
[0263]
[0264]
[0265]
[0266]
[0267]
[0268]
[0269]
[0270]
[0271]
[0272]
[0273]
[0274]
[0275]
[0276]
[0277]
[0278]
[0279]
[0280]
[0281]
[0282]
[0283]
[0284]
[0285]
[0286]
[0287]
[0288]
[0289]
[0290]
[0291]
[0292]
[0293]
[0294]
[0295]
[0296]
[0297]
[0298]
[0299]
[0300]
[0301]
[0302]
[0303]
[0304]
[0305]
[0306]
[0307]
[0308]
[0309]
[0310]
[0311]
[0312]
[0313]
[0314]
[0315]
[0316]
[0317]
[0318]
[0319]
[0320]
[0321]
[0322]
[0323]
[0324]
[0325]
[0326]
[0327]
[0328]
[0329]
[0330]
[0331]
[0332]
[0333]
[0334]
[0335]
[0336]
[0337]
[0338]
[0339]
[0340]
[0341]
[0342]
[0343]
[0344]
[0345]
[0346]
[0347]
[0348]
[0349]
[0350]
[0351]
[0352]
[0353]
[0354]
[0355]
[0356]
[0357]
[0358]
[0359]
[0360]
[0361]
[0362]
[0363]
[0364]
[0365]
[0366]
[0367]
[0368]
[0369]
[0370]
[0371]
[0372]
[0373]
[0374]
[0375]
[0376]
[0377]
[0378]
[0379]
[0380]
[0381]
[0382]
[0383]
[0384]
[0385]
[0386]
[0387]
[0388]
[0389]
[0390]
[0391]
[0392]
[0393]
[0394]
[0395]
[0396]
[0397]
[0398]
[0399]
[0400]
[0401]
[0402]
[0403]
[0404]
[0405]
[0406]
[0407]
[0408]
[0409]
[0410]
[0411]
[0412]
[0413]
[0414]
[0415]
[0416]
[0417]
[0418]
[0419]
[0420]
[0421]
[0422]
[0423]
[0424]
[0425]
[0426]
[0427]
[0428]
[0429]
[0430]
[0431]
[0432]
[0433]
[0434]
[0435]
[0436]
[0437]
[0438]
[0439]
[0440]
[0441]
[0442]
[0443]
[0444]
[0445]
[0446]
[0447]
[0448]
[0449]
[0450]
[0451]
[0452]
[0453]
[0454]
[0455]
[0456]
[0457]
[0458]
[0459]
[0460]
[0461]
[0462]
[0463]
[0464]
[0465]
[0466]
[0467]
[0468]
[0469]
[0470]
[0471]
[0472]
[0473]
[0474]
[0475]
[0476]
[0477]
[0478]
[0479]
[0480]
[0481]
[0482]
[0483]
[0484]
[0485]
[0486]
[0487]
[0488]
[0489]
[0490]
[0491]
[0492]
[0493]
[0494]
[0495]
[0496]
[0497]
[0498]
[0499]
[0500]
[0501]
[0502]
[0503]
[0504]
[0505]
[0506]
[0507]
[0508]
[0509]
[0510]
[0511]
[0512]
[0513]
[0514]
[0515]
[0516]
[0517]
[0518]
[0519]
[0520]
[0521]
[0522]
[0523]
[0524]
[0525]
[0526]
[0527]
[0528]
[0529]
[0530]
[0531]
[0532]
[0533]
[0534]
[0535]
[0536]
[0537]
[0538]
[0539]
[0540]
[0541]
[0542]
[0543]
[0544]
[0545]
[0546]
[0547]
[0548]
[0549]
[0550]
[0551]
[0552]
[0553]
[0554]
[0555]
[0556]
[0557]
[0558]
[0559]
[0560]
[0561]
[0562]
[0563]
[0564]
[0565]
[0566]
[0567]
[0568]
[0569]
[0570]
[0571]
[0572]
[0573]
[0574]
[0575]
[0576]
[0577]
[0578]
[0579]
[0580]
[0581]
[0582]
[0583]
[0584]
[0585]
[0586]
[0587]
[0588]
[0589]
[0590]
[0591]
[0592]
[0593]
[0594]
[0595]
[0596]
[0597]
[0598]
[0599]
[0600]
[0601]
[0602]
[0603]
[0604]
[0605]
[0606]
[0607]
[0608]
[0609]
[0610]
[0611]
[0612]
[0613]
[0614]
[0615]
[0616]
[0617]
[0618]
[0619]
[0620]
[0621]
[0622]
[0623]
[0624]
[0625]
[0626]
[0627]
[0628]
[0629]
[0630]
[0631]
[0632]
[0633]
[0634]
[0635]
[0636]
[0637]
[0638]
[0639]
[0640]
[0641]
[0642]
[0643]
[0644]
[0645]
[0646]
[0647]
[0648]
[0649]
[0650]
[0651]
[0652]
[0653]
[0654]
[0655]
[0656]
[0657]
[0658]
[0659]
[0660]
[0661]
[0662]
[0663]
[0664]
[0665]
[0666]
[0667]
[0668]
[0669]
[0670]
[0671]
[0672]
[0673]
[0674]
[0675]
[0676]
[0677]
[0678]
[0679]
[0680]
[0681]
[0682]
[0683]
[0684]
[0685]
[0686]
[0687]
[0688]
[0689]
[0690]
[0691]
[0692]
[0693]
[0694]
[0695]
[0696]
[0697]
[0698]
[0699]
[0700]
[0701]
[0702]
[0703]
[0704]
[0705]
[0706]
[0707]
[0708]
[0709]
[0710]
[0711]
[0712]
[0713]
[0714]
[0715]
[0716]
[0717]
[0718]
[0719]
[0720]
[0721]
[0722]
[0723]
[0724]
[0725]
[0726]
[0727]
[0728]
[0729]
[0730]
[0731]
[0732]
[0733]
[0734]
[0735]
[0736]
[0737]
[0738]
[0739]
[0740]
[0741]
[0742]
[0743]
[0744]
[0745]
[0746]
[0747]
[0748]
[0749]
[0750]
[0751]
[0752]
[0753]
[0754]
[0755]
[0756]
[0757]
[0758]
[0759]
[0760]
[0761]
[0762]
[0763]
[0764]
[0765]
[0766]
[0767]
[0768]
[0769]
[0770]
[0771]
[0772]
[0773]
[0774]
[0775]
[0776]
[0777]
[0778]
[0779]
[0780]
[0781]
[0782]
[0783]
[0784]
[0785]
[0786]
[0787]
[0788]
[0789]
[0790]
[0791]
[0792]
[0793]
[0794]
[0795]
[0796]
[0797]
[0798]
[0799]
[0800]
[0801]
[0802]
[0803]
[0804]
[0805]
[0806]
[0807]
[0808]
[0809]
[0810]
[0811]
[0812]
[0813]
[0814]
[0815]
[0816]
[0817]
[0818]
[0819]
[0820]
[0821]
[0822]
[0823]
[0824]
[0825]
[0826]
[0827]
[0828]
[0829]
[0830]
[0831]
[0832]
[0833]
[0834]
[0835]
[0836]
[0837]
[0838]
[0839]
[0840]
[0841]
[0842]
[0843]
[0844]
[0845]
[0846]
[0847]
[0848]
[0849]
[0850]
[0851]
[0852]
[0853]
[0854]
[0855]
[0856]
[0857]
[0858]
[0859]
[0860]
[0861]
[0862]
[0863]
[0864]
[0865]
[0866]
[0867]
[0868]
[0869]
[0870]
[0871]
[0872]
[0873]
[0874]
[0875]
[0876]
[0877]
[0878]
[0879]
[0880]
[0881]
[0882]
[0883]
[0884]
[0885]
[0886]
[0887]
[0888]
[0889]
[0890]
[0891]
[0892]
[0893]
[0894]
[0895]
[0896]
[0897]
[0898]
[0899]
[0900]
[0901]
[0902]
[0903]
[0904]
[0905]
[0906]
[0907]
[0908]
[0909]
[0910]
[0911]
[0912]
[0913]
[0914]
[0915]
[0916]
[0917]
[0918]
[0919]
[0920]
[0921]
[0922]
[0923]
[0924]
[0925]
[0926]
[0927]
[0928]
[0929]
[0930]
[0931]
[0932]
[0933]
[0934]
[0935]
[0936]
[0937]
[0938]
[0939]
[0940]
[0941]
[0942]
[0943]
[0944]
[0945]
[0946]
[0947]
[0948]
[0949]
[0950]
[0951]
[0952]
[0953]
[0954]
[0955]
[0956]
[0957]
[0958]
[0959]
[0960]
[0961]
[0962]
[0963]
[0964]
[0965]
[0966]
[0967]
[0968]
[0969]
[0970]
[0971]
[0972]
[0973]
[0974]
[0975]
[0976]
[0977]
[0978]
[0979]
[0980]
[0981]
[0982]
[0983]
[0984]
[0985]
[0986]
[0987]
[0988]
[0989]
[0990]
[0991]
[0992]
[0993]
[0994]
[0995]
[0996]
[0997]
[0998]
[0999]
[1000]
[1001]
[1002]
[1003]
[1004]
[1005]
[1006]
[1007]
[1008]
[1009]
[1010]
[1011]
[1012]
[1013]
[1014]
[1015]
[1016]
[1017]
[1018]
[1019]
[1020]
[1021]
[1022]
[1023]
[1024]
[1025]
[1026]
[1027]
[1028]
[1029]
[1030]
[1031]
[1032]
[1033]
[1034]
[1035]
[1036]
[1037]
[1038]
[1039]
[1040]
[1041]
[1042]
[1043]
[1044]
[1045]
[1046]
[1047]
[1048]
[1049]
[1050]
[1051]
[1052]
[1053]
[1054]
[1055]
[1056]
[1057]
[1058]
[1059]
[1060]
[1061]
[1062]
[1063]
[1064]
[1065]
[1066]
[1067]
[1068]
[1069]
[1070]
[1071]
[1072]
[1073]
[1074]
[1075]
[1076]
[1077]
[1078]
[1079]
[1080]
[1081]
[1082]
[1083]
[1084]
[1085]
[1086]
[1087]
[1088]
[1089]
[1090]
[1091]
[1092]
[1093]
[1094]
[1095]
[1096]
[1097]
[1098]
[1099]
[1100]
[1101]
[1102]
[1103]
[1104]
[1105]
[1106]
[1107]
[1108]
[1109]
[1110]
[1111]
[1112]
[1113]
[1114]
[1115]
[1116]
[1117]
[1118]
[1119]
[1120]
[1121]
[1122]
[1123]
[1124]
[1125]
[1126]
[1127]
[1128]
[1129]
[1130]
[1131]
[1132]
[1133]
[1134]
[1135]
[1136]
[1137]
[1138]
[1139]
[1140]
[1141]
[1142]
[1143]
[1144]
[1145]
[1146]
[1147]
[1148]
[1149]
[1150]
[1151]
[1152]
[1153]
[1154]
[1155]
[1156]
[1157]
[1158]
[1159]
[1160]
[1161]
[1162]
[1163]
[1164]
[1165]
[1166]
[1167]
[1168]
[1169]
[1170]
[1171]
[1172]
[1173]
[1174]
[1175]
[1176]
[1177]
[1178]
[1179]
[1180]
[1181]
[1182]
[1183]
[1184]
[1185]
[1186]
[1187]
[1188]
[1189]
[1190]
[1191]
[1192]
[1193]
[1194]
[1195]
[1196]
[1197]
[1198]
[1199]
[1200]
[1201]
[1202]
[1203]
[1204]
[1205]
[1206]
[1207]
[1208]
[1209]
[1210]
[1211]
[1212]
[1213]
[1214]
[1215]
[1216]
[1217]
[1218]
[1219]
[1220]
[1221]
[1222]
[1223]
[1224]
[1225]
[1226]
[1227]
[1228]
[1229]
[1230]
[1231]
[1232]
[1233]
[1234]
[1235]
[1236]
[1237]
[1238]
[1239]
[1240]
[1241]
[1242]
[1243]
[1244]
[1245]
[1246]
[1247]
[1248]
[1249]
[1250]
[1251]
[1252]
[1253]
[1254]
[1255]
[1256]
[1257]
[1258]
[1259]
[1260]
[1261]
[1262]
[1263]
[1264]
[1265]
[1266]
[1267]
[1268]
[1269]
[1270]
[1271]
[1272]
[1273]
[1274]
[1275]
[1276]
[1277]
[1278]
[1279]
[1280]
[1281]
[1282]
[1283]
[1284]
[1285]
[1286]
[1287]
[1288]
[1289]
[1290]
[1291]
[1292]
[1293]
[1294]
[1295]
[1296]
[1297]
[1298]
[1299]
[1300]
[1301]
[1302]
[1303]
[1304]
[1305]
[1306]
[1307]
[1308]
[1309]
[1310]
[1311]
[1312]
[1313]
[1314]
[1315]
[1316]
[1317]
[1318]
[1319]
[1320]
[1321]
[1322]
[1323]
[1324]
[1325]
[1326]
[1327]
[1328]
[1329]
[1330]
[1331]
[1332]
[1333]
[1334]
[1335]
[1336]
[1337]
[1338]
[1339]
[1340]
[1341]
[1342]
[1343]
[1344]
[1345]
[1346]
[1347]
[1348]
[1349]
[1350]
[1351]
[1352]
[1353]
[1354]
[1355]
[1356]
[1357]
[1358]
[1359]
[1360]
[1361]
[1362]
[1363]
[1364]
[1365]
[1366]
[1367]
[1368]
[1369]
[1370]
[1371]
[1372]
[1373]
[1374]
[1375]
[1376]
[1377]
[1378]
[1379]
[1380]
[1381]
[1382]
[1383]
[1384]
[1385]
[1386]
[1387]
[1388]
[1389]
[1390]
[1391]
[1392]
[1393]
[1394]
[1395]
[1396]
[1397]
[1398]
[1399]
[1400]
[1401]
[1402]
[1403]
[1404]
[1405]
[1406]
[1407]
[1408]
[1409]
[1410]
[1411]
[1412]
[1413]
[1414]
[1415]
[1416]
[1417]
[1418]
[1419]
[1420]
[1421]
[1422]
[1423]
[1424]
[1425]
[1426]
[1427]
[1428]
[1429]
[1430]
[1431]
[1432]
[1433]
[1434]
[1435]
[1436]
[1437]
[1438]
[1439]
[1440]
[1441]
[1442]
[1443]
[1444]
[1445]
[1446]
[1447]
[1448]
[1449]
[1450]
[1451]
[1452]
[1453]
[1454]
[1455]
[1456]
[1457]
[1458]
[1459]
[1460]
[1461]
[1462]
[1463]
[1464]
[1465]
[1466]
[1467]
[1468]
[1469]
[1470]
[1471]
[1472]
[1473]
[1474]
[1475]
[1476]
[1477]
[1478]
[1479]
[1480]
[1481]
[1482]
[1483]
[1484]
[1485]
[1486]
[1487]
[1488]
[1489]
[1490]
[1491]
[1492]
[1493]
[1494]
[1495]
[1496]
[1497]
[1498]
[1499]
[1500]
[1501]
[1502]
[1503]
[1504]
[1505]
[1506]
[1507]
[1508]
[1509]
[1510]
[1511]
[1512]
[1513]
[1514]
[1515]
[1516]
[1517]
[1518]
[1519]
[1520]
[1521]
[1522]
[1523]
[1524]
[1525]
[1526]
[1527]
[1528]
[1529]
[1530]
[1531]
[1532]
[1533]
[1534]
[1535]
[1536]
[1537]
[1538]
[1539]
[1540]
[1541]
[1542]
[1543]
[1544]
[1545]
[1546]
[1547]
[1548]
[1549]
[1550]
[1551]
[1552]
[1553]
[1554]
[1555]
[1556]
[1557]
[1558]
[1559]
[1560]
[1561]
[1562]
[1563]
[1564]
[1565]
[1566]
[1567]
[1568]
[1569]
[1570]
[1571]
[1572]
[1573]
[1574]
[1575]
[1576]
[1577]
[1578]
[1579]
[1580]
[1581]
[1582]
[1583]
[1584]
[1585]
/*****************************************************************************/
/*
HyperSpi$agent.c
This is the System Performance Information collection agent for the Hypertext
SPI facility. It executes on selected nodes, writing selected system
performance information into a data file, once every minute. The data
contains per-minute average and total values (depending on the datum), and
peak values based on the granularity of whatever is the collection period
(currently 1 second). These data files are kept on a per-day basis. This
data may then be processed and displayed by the Hypertext SPI facility.
It utilizes the undocumented EXE$GETSPI interface for Alpha and VAX, the
documented and supported (as from V7.3) $GETRMI interface for Itanium.
Original idea and details plagiarised (and extensively reworked) from a VMS
X Window System utility named SPI.
BUILD DETAILS
-------------
See BUILD_HYPERSPI$AGENT.COM procedure.
COPYRIGHT
---------
Copyright (C) 1995-2021 Mark G.Daniel
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
VERSION HISTORY (update SOFTWAREVN as well!)
---------------
14-OCT-2014 MGD v2.1.0, bump version in line with HYPERSPI.C
21-MAY-2011 MGD v2.0.0, port to Itanium (changed the size of some data)
add network interface data
data format version 3 (shared with HyperSPI++)
(There is a lot of work that *could* be done to this
older piece of code but I've spent the minimal time
necessary just to make it work on modern platforms.)
23-DEC-2003 MGD v1.1.1, minor conditional mods to support IA64
09-SEP-2001 MGD v1.1.0, provide PID logical name to allow $FORCEX
07-JUL-2001 MGD v1.0.4, remove 'register' from storage declarations
15-FEB-2001 MGD v1.0.3, bugfix; MBytes memory for systems >= 4096MB
28-OCT-2000 MGD v1.0.2, make adjustments for RELEAXED_ANSI compilation
10-AUG-2000 MGD v1.0.1, work around HPARITH exception with lib$cvtf()
13-AUG-1998 MGD NOTE: this application is not Y2K compliant (in the sense
data is stored in files named with a 2 digit year!)
20-JUN-1995 MGD v1.0.0, initial development
*/
/*****************************************************************************/
#define SOFTWAREVN "2.1.0"
#define SOFTWARENM "HYPERSPI$AGENT"
#ifdef __ALPHA
char SoftwareID [] = SOFTWARENM " AXP-" SOFTWAREVN;
#endif
#ifdef __ia64
char SoftwareID [] = SOFTWARENM " IA64-" SOFTWAREVN;
#endif
#ifdef __VAX
char SoftwareID [] = SOFTWARENM " VAX-" SOFTWAREVN;
#endif
#ifdef __x86_64
char SoftwareID [] = SOFTWARENM " X86-" SOFTWAREVN;
#endif
/* standard C header files */
#include <errno.h>
#include <math.h>
#include <stdlib.h>
#include <stdio.h>
/* VMS-related header files */
#include <descrip.h>
#include <dvidef.h>
#include <dvsdef.h>
#include <jpidef.h>
#include <libdtdef.h>
#include <lnmdef.h>
#include <psldef.h>
#include <iodef.h>
#include <ssdef.h>
#include <stsdef.h>
#include <syidef.h>
#include <rms.h>
#include <rmsdef.h>
/* Alpha and VAX will use the EXE$SPI interface, Itanium will use $GETRMI */
#ifdef __ia64
#include <rmidef.h>
#endif
/* application header file */
#include "hyperspi.h"
#include "spidef.h"
#ifndef __VAX
# pragma nomember_alignment
#endif
#define boolean int
#define true 1
#define false 0
#define VMSok(x) ((x) & STS$M_SUCCESS)
#define VMSnok(x) !(((x) & STS$M_SUCCESS))
#define COLLECT_INTERVAL_SECONDS 1
#define RECORD_INTERVAL_SECONDS 60
#define CPU_MODE_COUNT HYPERSPI_CPU_MODE_COUNT
#define NI_DEVICE_MAX 8
boolean Debug = 0,
DebugSpi = 0;
unsigned long ActiveCpuCnt,
AvailCpuCnt,
EfnTimer,
EfnSpi,
SyiMemSize,
SyiPageSize;
#ifdef __RMIDEF_LOADED
unsigned __int64 TotalCpuTicks,
TotalUserModeCpuTicks;
unsigned __int64 TotalModeCpuTicks[CPU_MODE_COUNT];
#else
unsigned int TotalCpuTicks,
TotalUserModeCpuTicks;
unsigned long TotalModeCpuTicks[CPU_MODE_COUNT];
#endif
float FloatNumberOfCPUs,
TotalDeltaSeconds;
char SyiNodeName [16];
unsigned long CurrentBinTime [2],
PreviousBinTime [2];
unsigned short CurrentNumTime [7];
unsigned long CollectSeconds [2] = { -10000000*COLLECT_INTERVAL_SECONDS, -1 };
float RecordSeconds = (float)(RECORD_INTERVAL_SECONDS-1);
/* this structure declared in HyperSpi.h */
struct HyperSpiData SpiRecord;
/* function prototypes */
void AgentPidLogicalAtExit ();
int CollectNetInt();
int CollectSystemDynamic();
int CollectSystemStatic();
void DebugSpiRecord ();
/*****************************************************************************/
/*
*/
int main ()
{
int idx, status;
unsigned short PrevMinute = 0;
float ftmp;
/*********/
/* begin */
/*********/
if (getenv ("HYPERSPI$DBUG") != NULL) Debug = true;
fprintf(stdout, "%s\n", SoftwareID);
AgentPidLogical (true);
if (VMSnok (status = lib$get_ef (&EfnTimer)))
exit (status);
if (VMSnok (status = lib$get_ef (&EfnSpi)))
exit (status);
/* set the process priority sufficiently high to have an edge */
if (VMSnok (status = sys$setpri (0, 0, 6, 0, 0, 0)))
exit (status);
/* get system name, physical memory size */
if (VMSnok (CollectSystemStatic ()))
exit (status);
SpiRecord.SystemMemoryMBytes = (SyiMemSize * (SyiPageSize / 512)) / 2048;
/* initialize the time in the data record, etc */
sys$gettim (&CurrentBinTime);
sys$numtim (&CurrentNumTime, &CurrentBinTime);
SpiRecord.Minute = PrevMinute = CurrentNumTime[4];
SpiRecord.Hour = CurrentNumTime[3];
SpiRecord.Day = CurrentNumTime[2];
SpiRecord.Month = CurrentNumTime[1];
SpiRecord.Year = CurrentNumTime[0];
/* initialise */
CollectSPI ();
/*****************/
/* infinite loop */
/*****************/
for (;;)
{
if (VMSnok (status = sys$setimr (EfnTimer, &CollectSeconds, 0, 0, 0)))
exit (status);
if (VMSnok (status = sys$waitfr (EfnTimer)))
exit (status);
/* get an update of the system time */
PreviousBinTime[0] = CurrentBinTime[0];
PreviousBinTime[1] = CurrentBinTime[1];
sys$gettim (&CurrentBinTime);
sys$numtim (&CurrentNumTime, &CurrentBinTime);
CollectSystemDynamic ();
CollectSPI ();
CollectNetInt ();
if (Debug) DebugSpiRecord ();
if (CurrentNumTime[4] != PrevMinute)
{
if (Debug)
fprintf (stdout, "TotalDeltaSeconds: %f\n", TotalDeltaSeconds);
if (TotalDeltaSeconds >= RecordSeconds)
{
if (Debug)
fprintf (stdout,
#ifdef __RMIDEF_LOADED
"TotalCpuTicks: %Lu TotalUserModeCpuTicks: %Lu\n",
#else
"TotalCpuTicks: %u TotalUserModeCpuTicks: %u\n",
#endif
TotalCpuTicks, TotalUserModeCpuTicks);
ftmp = (float)TotalCpuTicks /
TotalDeltaSeconds /
FloatNumberOfCPUs;
SpiRecord.PercentCPU = (unsigned char)ftmp;
if (ftmp - floor(ftmp) >= 0.5)
SpiRecord.PercentCPU++;
ftmp = (float)TotalUserModeCpuTicks /
TotalDeltaSeconds /
FloatNumberOfCPUs;
SpiRecord.PercentUserModeCPU = (unsigned char)ftmp;
if (ftmp - floor(ftmp) >= 0.5)
SpiRecord.PercentUserModeCPU++;
WriteSpiRecord ();
}
TotalCpuTicks = TotalUserModeCpuTicks =
SpiRecord.PercentCPU = SpiRecord.PeakPercentCPU =
SpiRecord.PercentUserModeCPU = SpiRecord.PeakPercentUserModeCPU =
SpiRecord.PageFaults = SpiRecord.PeakPageFaults =
SpiRecord.HardPageFaults = SpiRecord.PeakHardPageFaults =
SpiRecord.BufferedIO = SpiRecord.PeakBufferedIO =
SpiRecord.DirectIO = SpiRecord.PeakDirectIO =
SpiRecord.MscpIO = SpiRecord.PeakMscpIO = 0;
SpiRecord.NetIntTx[0] = SpiRecord.NetIntTx[1] =
SpiRecord.PeakNetIntTx =
SpiRecord.NetIntRx[0] = SpiRecord.NetIntRx[1] =
SpiRecord.PeakNetIntRx =
SpiRecord.PeakNetIntRxTx =
SpiRecord.LckLoc = SpiRecord.LckIn = SpiRecord.LckOut = 0;
for (idx = 0; idx < CPU_MODE_COUNT; ++idx)
TotalModeCpuTicks[idx] = 0;
for (idx = 0;
idx < sizeof(SpiRecord.Rfu)/sizeof(SpiRecord.Rfu[0]);
idx++)
SpiRecord.Rfu[idx] = 0;
for (idx = 0; idx < HYPERSPI_CPU_MODE_COUNT; idx++)
SpiRecord.PercentModeCPU[idx] = 0;
SpiRecord.Minute = PrevMinute = CurrentNumTime[4];
SpiRecord.Hour = CurrentNumTime[3];
SpiRecord.Day = CurrentNumTime[2];
SpiRecord.Month = CurrentNumTime[1];
SpiRecord.Year = CurrentNumTime[0];
TotalDeltaSeconds = 0.0;
}
}
/* should never get to here! */
exit (STS$K_ERROR);
}
/*****************************************************************************/
/*
Open the per-day data file, write the SPI record into it, close the file.
*/
WriteSpiRecord ()
{
static unsigned short PrevDay = 0;
static int DataFileNameLength;
static char DataFileName [256];
static struct FAB DataFileFab;
static struct RAB DataFileRab;
static struct XABPRO DataFileXabPro;
int status;
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "WriteSpiRecord()\n");
if (Debug) DebugSpiRecord ();
if (SpiRecord.Day != PrevDay)
{
PrevDay = SpiRecord.Day;
DataFileNameLength =
sprintf (DataFileName,
"%sHYPERSPI_%s_%s_%02.02d%02.02d%02.02d.DAT",
HYPERSPI_DATA_DIRECTORY, HYPERSPI_DATA_VERSION, SyiNodeName,
SpiRecord.Day, SpiRecord.Month, SpiRecord.Year % 100);
if (Debug) fprintf (stdout, "DataFileName |%s|\n", DataFileName);
DataFileFab = cc$rms_fab;
DataFileFab.fab$l_fop = FAB$M_CIF | FAB$M_SQO;
DataFileFab.fab$b_fac = FAB$M_PUT;
DataFileFab.fab$l_fna = DataFileName;
DataFileFab.fab$b_fns = DataFileNameLength;
DataFileFab.fab$w_mrs = sizeof(struct HyperSpiData);
DataFileFab.fab$b_org = FAB$C_SEQ;
DataFileFab.fab$b_rfm = FAB$C_FIX;
DataFileFab.fab$b_shr = FAB$M_SHRGET | FAB$M_SHRPUT;
DataFileFab.fab$l_xab = &DataFileXabPro;
DataFileRab = cc$rms_rab;
DataFileRab.rab$l_fab = &DataFileFab;
DataFileRab.rab$b_mbf = 2;
DataFileRab.rab$l_rop = RAB$M_EOF;
DataFileRab.rab$w_rsz = sizeof(struct HyperSpiData);
DataFileRab.rab$l_rbf = (char*)&SpiRecord;
/* initialize the extended access block (XAB) as a protection block */
DataFileXabPro.xab$b_bln = sizeof(DataFileXabPro);
DataFileXabPro.xab$b_cod = XAB$C_PRO;
DataFileXabPro.xab$l_nxt = 0;
DataFileXabPro.xab$w_pro = 0xee00; /* w:r,g:r,o:rwed,s:rwed */
}
if (VMSnok (status = sys$create (&DataFileFab, 0, 0)))
{
if (Debug) fprintf (stdout, "sys$create() %%X%08.08X\n", status);
exit (status);
}
if (VMSnok (status = sys$connect (&DataFileRab, 0, 0)))
{
if (Debug) fprintf (stdout, "sys$connect() %%X%08.08X\n", status);
sys$close (&DataFileFab, 0, 0);
exit (status);
}
if (VMSnok (status = sys$put (&DataFileRab, 0, 0)))
{
if (Debug) fprintf (stdout, "sys$put() %%X%08.08X\n", status);
sys$close (&DataFileFab, 0, 0);
exit (status);
}
sys$close (&DataFileFab, 0, 0);
}
/*****************************************************************************/
/*
Collect System Performance Information.
It utilizes the undocumented EXE$GETSPI interface for Alpha and VAX, the
documented and supported (as from V7.3) $GETRMI interface for Itanium.
*/
#define MODE_INTERRUPT 0
#define MODE_MULTIPROC 1
#define MODE_KERNEL 2
#define MODE_EXECUTIVE 3
#define MODE_SUPERVISOR 4
#define MODE_USER 5
#define MODE_COMPAT 6
#define MODE_NULL 7
int CollectSPI ()
{
const long cvtf_mode = LIB$K_DELTA_SECONDS_F;
static unsigned long ProcessCount,
CpuTicks,
UserModeCpuTicks,
PageFaults,
PrevPageFaults = 0,
HardPageFaults,
PrevHardPageFaults = 0,
PageReadIO,
PrevPageReadIO = 0,
PageWriteIO,
PrevPageWriteIO = 0,
BufferedIO,
PrevBufferedIO = 0,
DirectIO,
PrevDirectIO = 0,
MscpIO,
PrevMscpIO = 0,
LckLoc[2],
PrevLckLoc[2] = {0, 0},
LckIn[2],
PrevLckIn[2] = {0, 0},
LckOut[2],
PrevLckOut[2] = {0, 0},
Com,
ComO;
/* storage for VMS binary time */
static unsigned long DiffBinTime [2];
#ifdef __RMIDEF_LOADED
static unsigned __int64 CpuExec,
CpuIntStk,
CpuKernel,
CpuMpSynch,
CpuSuper,
CpuUser,
FreeList;
static unsigned __int64 ModeCpuTicks[HYPERSPI_CPU_MODE_COUNT];
static unsigned long MscpData [35];
#else /* __RMIDEF_LOADED */
static unsigned long FreeList;
static unsigned long MscpData[13],
ModeCpuTicks[HYPERSPI_CPU_MODE_COUNT];
#endif /* __RMIDEF_LOADED */
#ifndef __VAX
# pragma member_alignment __save
# pragma nomember_alignment
#endif
/* structure for a single CPU's mode ticks */
static struct SingleCPU {
unsigned char CPUid;
unsigned long Count[8];
};
/* a structure all CPU's mode ticks for a system with up to 32 CPUs */
static struct {
unsigned long NumberOfCPUs;
struct SingleCPU CPU[32];
} ModeTicks;
#ifdef __RMIDEF_LOADED
/* initialize structure for RMI items */
static struct {
short BufferLength;
short ItemCode;
void *BufferPtr;
void *LengthPtr;
} ItemList[] =
{
/* for 7.3-2(?) and later which has the RMI$_CPU_... items */
{ sizeof(CpuExec), RMI$_CPUEXEC, &CpuExec, 0 },
{ sizeof(CpuIntStk), RMI$_CPUINTSTK, &CpuIntStk, 0 },
{ sizeof(CpuKernel), RMI$_CPUKERNEL, &CpuKernel, 0 },
{ sizeof(CpuMpSynch), RMI$_CPUMPSYNCH, &CpuMpSynch, 0 },
{ sizeof(CpuSuper), RMI$_CPUSUPER, &CpuSuper, 0 },
{ sizeof(CpuUser), RMI$_CPUUSER, &CpuUser, 0 },
{ sizeof(FreeList), RMI$_FRLIST, &FreeList, 0 },
{ sizeof(PageFaults), RMI$_FAULTS, &PageFaults, 0 },
{ sizeof(PageReadIO), RMI$_PREADIO, &PageReadIO, 0 },
{ sizeof(PageWriteIO), RMI$_PWRITIO, &PageWriteIO, 0 },
{ sizeof(BufferedIO), RMI$_BUFIO, &BufferedIO, 0 },
{ sizeof(DirectIO), RMI$_DIRIO, &DirectIO, 0 },
{ sizeof(Com), RMI$_COM, &Com, 0 },
{ sizeof(ComO), RMI$_COMO, &ComO, 0 },
{ sizeof(ProcessCount), RMI$_PROCS, &ProcessCount, 0 },
{ sizeof(MscpData), RMI$_MSCP_EVERYTHING, &MscpData, 0 },
{ sizeof(LckLoc[0]), RMI$_ENQNEWLOC, &(LckLoc[0]), 0 },
{ sizeof(LckIn[0]), RMI$_ENQNEWIN, &(LckIn[0]), 0 },
{ sizeof(LckOut[0]), RMI$_ENQNEWOUT, &(LckOut[0]), 0 },
{ sizeof(LckLoc[1]), RMI$_ENQCVTLOC, &(LckLoc[1]), 0 },
{ sizeof(LckIn[1]), RMI$_ENQCVTIN, &(LckIn[1]), 0 },
{ sizeof(LckOut[1]), RMI$_ENQCVTOUT, &(LckOut[1]), 0 },
{0,0,0,0}
};
#else /* __RMIDEF_LOADED */
/* initialize structure for SPI items */
static struct {
short BufferLength;
short ItemCode;
void *BufferPtr;
void *LengthPtr;
} ItemList[] =
{
{ sizeof(ModeTicks), SPI$_MODES, &ModeTicks, 0 },
{ sizeof(unsigned long), SPI$_FRLIST, &FreeList, 0 },
{ sizeof(unsigned long), SPI$_FAULTS, &PageFaults, 0 },
{ sizeof(unsigned long), SPI$_PREADIO, &PageReadIO, 0 },
{ sizeof(unsigned long), SPI$_PWRITIO, &PageWriteIO, 0 },
{ sizeof(unsigned long), SPI$_BUFIO, &BufferedIO, 0 },
{ sizeof(unsigned long), SPI$_DIRIO, &DirectIO, 0 },
{ sizeof(unsigned long), SPI$_COM, &Com, 0 },
{ sizeof(unsigned long), SPI$_COMO, &ComO, 0 },
{ sizeof(unsigned long), SPI$_PROCS, &ProcessCount, 0 },
{ sizeof(MscpData), SPI$_MSCP_ALL, &MscpData, 0 },
{ sizeof(unsigned long), SPI$_ENQNEWLOC, &(LckLoc[0]), 0 },
{ sizeof(unsigned long), SPI$_ENQNEWIN, &(LckIn[0]), 0 },
{ sizeof(unsigned long), SPI$_ENQNEWOUT, &(LckOut[0]), 0 },
{ sizeof(unsigned long), SPI$_ENQCVTLOC, &(LckLoc[1]), 0 },
{ sizeof(unsigned long), SPI$_ENQCVTIN, &(LckIn[1]), 0 },
{ sizeof(unsigned long), SPI$_ENQCVTOUT, &(LckOut[1]), 0 },
{0,0,0,0}
};
#endif /* __RMIDEF_LOADED */
#ifndef __VAX
# pragma member_alignment __restore
#endif
#ifdef __RMIDEF_LOADED
static unsigned __int64 PrevModes[8];
#else
static unsigned long PrevModes[8];
#endif
int status;
#ifdef __RMIDEF_LOADED
unsigned __int64 tmp;
unsigned __int64 CurrentModes[8];
#else
unsigned long tmp;
unsigned long CurrentModes[8];
#endif
unsigned long cidx, midx;
float DeltaSeconds;
IOSBLK IOsb;
/*********/
/* begin */
/*********/
/* collect System Performance Information */
#ifdef __RMIDEF_LOADED
status = sys$getrmi (
EfnSpi, /* efn */
0, /* csiaddr */
0, /* nodename */
&ItemList, /* item list */
&IOsb, /* iosb */
0, /* astaddr */
0 ); /* astprm */
if (Debug)
fprintf (stdout, "sys$getrmi() %%X%08.08X IOsb: %%X%08.08X\n",
status, IOsb.iosb$w_status);
#else /* __RMIDEF_LOADED */
status = exe$getspi (
EfnSpi, /* efn */
0, /* csiaddr */
0, /* nodename */
&ItemList, /* item list */
&IOsb, /* iosb */
0, /* astaddr */
0 ); /* astprm */
if (Debug)
fprintf (stdout, "exe$getspi() %%X%08.08X IOsb: %%X%08.08X\n",
status, IOsb.iosb$w_status);
#endif /* __RMIDEF_LOADED */
if (VMSnok (status)) return (status);
if (VMSnok (status = sys$waitfr (EfnSpi))) exit (status);
/**************************/
/* calculate elapsed time */
/**************************/
lib$sub_times (&CurrentBinTime, &PreviousBinTime, &DiffBinTime);
#ifdef __RMIDEF_LOADED
status = lib$cvts_from_internal_time (&cvtf_mode, &DeltaSeconds,
&DiffBinTime);
#else
status = lib$cvtf_from_internal_time (&cvtf_mode, &DeltaSeconds,
&DiffBinTime);
#endif
TotalDeltaSeconds += DeltaSeconds;
if (Debug)
fprintf (stdout, "DeltaSeconds: %f TotalDeltaSeconds: %f\n",
DeltaSeconds, TotalDeltaSeconds);
/**********************/
/* calculate CPU time */
/**********************/
#ifdef __RMIDEF_LOADED
CurrentModes[MODE_INTERRUPT] = CpuIntStk;
CurrentModes[MODE_EXECUTIVE] = CpuExec;
CurrentModes[MODE_KERNEL] = CpuKernel;
CurrentModes[MODE_MULTIPROC] = CpuMpSynch;
CurrentModes[MODE_USER] = CpuUser;
CurrentModes[MODE_SUPERVISOR] = CpuSuper;
CurrentModes[MODE_COMPAT] = CurrentModes[MODE_NULL] = 0;
#else /* __RMIDEF_LOADED */
if (Debug)
{
for (cidx = 0; cidx < ModeTicks.NumberOfCPUs; cidx++)
for (midx = MODE_INTERRUPT; midx <= MODE_NULL; midx++)
fprintf (stdout, "[%d][%d] = %u\n",
cidx, midx, ModeTicks.CPU[cidx].Count[midx]);
}
/* accumulate mode counters for all CPUs into CPU 0's area */
for (cidx = 1; cidx < ModeTicks.NumberOfCPUs; cidx++)
for (midx = MODE_INTERRUPT; midx <= MODE_NULL; midx++)
ModeTicks.CPU[0].Count[midx] += ModeTicks.CPU[cidx].Count[midx];
/* current raw CPU ticks */
CurrentModes[MODE_INTERRUPT] = ModeTicks.CPU[0].Count[MODE_INTERRUPT] -
ModeTicks.CPU[0].Count[MODE_NULL];
CurrentModes[MODE_MULTIPROC] = ModeTicks.CPU[0].Count[MODE_MULTIPROC];
CurrentModes[MODE_KERNEL] = ModeTicks.CPU[0].Count[MODE_KERNEL];
CurrentModes[MODE_EXECUTIVE] = ModeTicks.CPU[0].Count[MODE_EXECUTIVE];
CurrentModes[MODE_SUPERVISOR] = ModeTicks.CPU[0].Count[MODE_SUPERVISOR];
CurrentModes[MODE_USER] = ModeTicks.CPU[0].Count[MODE_USER];
CurrentModes[MODE_COMPAT] = ModeTicks.CPU[0].Count[MODE_COMPAT];
CurrentModes[MODE_NULL] = ModeTicks.CPU[0].Count[MODE_NULL];
#endif /* __RMIDEF_LOADED */
/* calculate the number of CPU ticks for this period */
CpuTicks = 0;
for (midx = MODE_INTERRUPT; midx <= MODE_COMPAT; midx++)
{
tmp = CurrentModes[midx];
#ifndef __VAX
/*
It has been OBSERVED that in this application Interrupt mode
counters can actually go backwards (only ever observed by 1).
Don't know if this is an artifact of the code, or what?
This kludge doesn't seem to cause any problems, but will look
for a better solution/explanation when time permits.
*/
if (CurrentModes[midx] >= PrevModes[midx])
CurrentModes[midx] = tmp - PrevModes[midx];
else
CurrentModes[midx] = 0;
#else
CurrentModes[midx] = tmp - PrevModes[midx];
#endif /* __VAX */
PrevModes[midx] = tmp;
/* keep track of the total ticks */
CpuTicks += CurrentModes[midx];
}
UserModeCpuTicks = CurrentModes[MODE_USER] + CurrentModes[MODE_COMPAT];
ModeCpuTicks[HYPERSPI_MODE_USER] = UserModeCpuTicks;
ModeCpuTicks[HYPERSPI_MODE_INTERRUPT] = CurrentModes[MODE_INTERRUPT];
ModeCpuTicks[HYPERSPI_MODE_MULTIPROC] = CurrentModes[MODE_MULTIPROC];
ModeCpuTicks[HYPERSPI_MODE_KERNEL] = CurrentModes[MODE_KERNEL];
ModeCpuTicks[HYPERSPI_MODE_EXECUTIVE] = CurrentModes[MODE_EXECUTIVE];
ModeCpuTicks[HYPERSPI_MODE_SUPERVISOR] = CurrentModes[MODE_SUPERVISOR];
if (Debug)
{
fprintf (stdout,
#ifdef __RMIDEF_LOADED
"ticks CPU\nI: %Lu\nMP: %Lu\nK: %Lu\nE: %Lu\nS: %Lu\nU: %Lu\nC: %Lu\n?: %Lu\n",
#else
"ticks CPU\nI: %u\nMP: %u\nK: %u\nE: %u\nS: %u\nU: %u\nC: %u\n?: %u\n",
#endif
CurrentModes[0], CurrentModes[1], CurrentModes[2], CurrentModes[3],
CurrentModes[4], CurrentModes[5], CurrentModes[6], CurrentModes[7]);
}
/*******************/
/* calculate other */
/*******************/
if (Debug)
{
fprintf (stdout,
"CPU ticks %u\n\
CPU user mode ticks %u\n\
Free list: %u\n\
Page faults: %u %u hard\n\
Com: %u\n\
ComO: %u\n\
Buffered I/O: %u\n\
Direct I/O: %u\n\
Processes: %u\n\
MSCP: %u %u %u %u %u %u %u %u %u %u %u %u %u\n\
Locks: %u %u %u %u %u %u\n",
CpuTicks, UserModeCpuTicks,
(unsigned long)FreeList, PageFaults, PageReadIO+PageWriteIO,
Com, ComO,
BufferedIO, DirectIO, ProcessCount,
MscpData[0], MscpData[1], MscpData[2], MscpData[3], MscpData[4],
MscpData[5], MscpData[6], MscpData[7], MscpData[8], MscpData[9],
MscpData[10], MscpData[11], MscpData[12],
LckLoc[0], LckIn[0], LckOut[0], LckLoc[1], LckIn[1], LckOut[1]);
}
/***********************/
/* update the counters */
/***********************/
FloatNumberOfCPUs = (float)(SpiRecord.NumberOfCPUs = ActiveCpuCnt);
SpiRecord.SystemMemoryPercentInUse =
((SyiMemSize - FreeList) * 100) / SyiMemSize;
SpiRecord.NumberOfProcesses = ProcessCount;
/* 'PrevPageFaults' will only be zero first time function is called */
if (PrevPageFaults)
{
int i = 0;
TotalCpuTicks += CpuTicks;
TotalUserModeCpuTicks += UserModeCpuTicks;
for (i = 0; i < CPU_MODE_COUNT; ++i)
TotalModeCpuTicks[i] += ModeCpuTicks[i];
if (DeltaSeconds < 1.0) DeltaSeconds = 1.0;
tmp = (int)((float)CpuTicks / DeltaSeconds / FloatNumberOfCPUs);
if (tmp > SpiRecord.PeakPercentCPU)
SpiRecord.PeakPercentCPU = tmp;
tmp = (int)((float)UserModeCpuTicks / DeltaSeconds / FloatNumberOfCPUs);
if (tmp > SpiRecord.PeakPercentUserModeCPU)
SpiRecord.PeakPercentUserModeCPU = tmp;
}
if (PageFaults > PrevPageFaults)
{
if (PrevPageFaults)
{
SpiRecord.PageFaults += (tmp = PageFaults - PrevPageFaults);
if (tmp > SpiRecord.PeakPageFaults) SpiRecord.PeakPageFaults = tmp;
SpiRecord.HardPageFaults +=
(tmp = PageReadIO - PrevPageReadIO + PageWriteIO - PrevPageWriteIO);
if (tmp > SpiRecord.PeakHardPageFaults)
SpiRecord.PeakHardPageFaults = tmp;
}
PrevPageReadIO = PageReadIO;
PrevPageWriteIO = PageWriteIO;
}
/* Page faults counter can overflow */
PrevPageFaults = PageFaults;
SpiRecord.Computable = Com + ComO;
if (BufferedIO > PrevBufferedIO)
{
if (PrevBufferedIO)
{
SpiRecord.BufferedIO += (tmp = BufferedIO - PrevBufferedIO);
if (tmp > SpiRecord.PeakBufferedIO) SpiRecord.PeakBufferedIO = tmp;
}
PrevBufferedIO = BufferedIO;
}
if (DirectIO > PrevDirectIO)
{
if (PrevDirectIO)
{
SpiRecord.DirectIO += (tmp = DirectIO - PrevDirectIO);
if (tmp > SpiRecord.PeakDirectIO) SpiRecord.PeakDirectIO = tmp;
}
PrevDirectIO = DirectIO;
}
#ifdef __RMIDEF_LOADED
MscpIO = MscpData[23] + MscpData[24];
#else /* __RMIDEF_LOADED */
MscpIO = MscpData[0];
#endif /* __RMIDEF_LOADED */
if (MscpIO > PrevMscpIO)
{
if (PrevMscpIO)
{
SpiRecord.MscpIO += (tmp = MscpIO - PrevMscpIO);
if (tmp > SpiRecord.PeakMscpIO) SpiRecord.PeakMscpIO = tmp;
}
PrevMscpIO = MscpIO;
}
/* lock counters can overflow */
if (LckLoc[0] > PrevLckLoc[0]) {
SpiRecord.LckLoc += LckLoc[0] - PrevLckLoc[0];
}
PrevLckLoc[0] = LckLoc[0];
if (LckLoc[1] > PrevLckLoc[1]) {
SpiRecord.LckLoc += LckLoc[1] - PrevLckLoc[1];
}
PrevLckLoc[1] = LckLoc[1];
if (LckIn[0] > PrevLckIn[0]) {
SpiRecord.LckIn += LckIn[0] - PrevLckIn[0];
}
PrevLckIn[0] = LckIn[0];
if (LckIn[1] > PrevLckIn[1]) {
SpiRecord.LckIn += LckIn[1] - PrevLckIn[1];
}
PrevLckIn[1] = LckIn[1];
if (LckOut[0] > PrevLckOut[0]) {
SpiRecord.LckOut += LckOut[0] - PrevLckOut[0];
}
PrevLckOut[0] = LckOut[0];
if (LckOut[1] > PrevLckOut[1]) {
SpiRecord.LckOut += LckOut[1] - PrevLckOut[1];
}
PrevLckOut[1] = LckOut[1];
return (SS$_NORMAL);
}
/****************************************************************************/
/*
Get the size and amount of free space in the installed page file(s).
*/
int CollectSystemDynamic ()
{
static unsigned long PageFileSize,
PageFileFree;
static struct {
short BufferLength;
short ItemCode;
void *BufferPtr;
void *LengthPtr;
} SyiItems [] =
{
{ sizeof(ActiveCpuCnt), SYI$_ACTIVECPU_CNT, &ActiveCpuCnt, 0 },
{ sizeof(PageFileSize), SYI$_PAGEFILE_PAGE, &PageFileSize, 0 },
{ sizeof(PageFileFree), SYI$_PAGEFILE_FREE, &PageFileFree, 0 },
{0,0,0,0},
};
int status;
struct {
unsigned long Status;
unsigned long Reserved;
} IOsb;
/*********/
/* begin */
/*********/
status = sys$getsyiw (0, 0, 0, &SyiItems, &IOsb, 0, 0);
if (Debug)
fprintf (stdout, "sys$getsyiw() %%X%08.08X IOsb: %%X%08.08X\n",
status, IOsb.Status);
if (VMSnok (status)) return (status);
if (VMSnok (IOsb.Status)) return (IOsb.Status);
SpiRecord.PageSpaceMBytes = ((float)PageFileSize * SyiPageSize) / 1048576;
SpiRecord.PageSpacePercentInUse =
100 - (((float)PageFileFree * 100) / (float)PageFileSize);
if (Debug)
fprintf (stdout,
"AvailCpuCnt: %d ActiveCpuCnt: %d \
PageSpaceMBytes: %d PageSpacePercentInUse: %d\n",
AvailCpuCnt, ActiveCpuCnt,
SpiRecord.PageSpaceMBytes, SpiRecord.PageSpacePercentInUse);
return (SS$_NORMAL);
}
/****************************************************************************/
/*
Get node name, amount of physical memory, and memory page size.
*/
/* these are currently not in header files for VAX C */
/* discovered empirically on an AXP system using DEC C */
#define SYI$_PAGE_SIZE 4452
#define SYI$_MEMSIZE 4459
int CollectSystemStatic ()
{
int status;
unsigned short SyiNodeNameLength;
struct {
short BufferLength;
short ItemCode;
void *BufferPtr;
void *LengthPtr;
}
SyiItems [] =
{
{ 15, SYI$_NODENAME, &SyiNodeName, &SyiNodeNameLength },
{ 4, SYI$_MEMSIZE, &SyiMemSize, 0 },
{ 4, SYI$_PAGE_SIZE, &SyiPageSize, 0 },
{ sizeof(AvailCpuCnt), SYI$_AVAILCPU_CNT, &AvailCpuCnt, 0 },
{ 0,0,0,0 }
};
struct {
unsigned long Status;
unsigned long Reserved;
} IOsb;
/*********/
/* begin */
/*********/
status = sys$getsyiw (0, 0, 0, &SyiItems, &IOsb, 0, 0);
if (Debug)
fprintf (stdout, "sys$getsyiw() %%X%08.08X IOsb: %%X%08.08X\n",
status, IOsb.Status);
if (VMSok (IOsb.Status))
SyiNodeName[SyiNodeNameLength] = '\0';
else
SyiNodeName[0] = '\0';
if (VMSnok (IOsb.Status)) return (IOsb.Status);
return (SS$_NORMAL);
}
/*****************************************************************************/
/*
This function uses undocumented sense-mode functionality to load counters from
the network interface (commonly ethernet device). Multiple devices are
supported using a multi-valued logical name HYPERSPI$AGENT_NI and the
frame-rate and byte-rate and soft/hard error-rate statistics are accumlated to
represent total system data.
On Alpha and Itanium uses native 64 bit (quadword) accumulators.
Essential concepts have come from "EMON: moniteur ethernet (V2.1-2) Gerard
Guillaume" and found in DECUSLIB freeware, and from some peeks at the T4 source
code. The implementation is mine.
Adapted from the MONDESI.C development tree!
*/
int CollectNetInt ()
{
static int NetIntCount;
static unsigned short NetIntChan [NI_DEVICE_MAX];
static unsigned long DcSCOM = 32, /* DC$_SCOM */
DtNI = 13; /* DT$_NI */
#ifndef __VAX
static unsigned __int64 NetIntBlocksRx,
NetIntBlocksTx,
NetIntBytesRx,
NetIntBytesTx,
PrevBlocksRx,
PrevBlocksTx,
PrevBytesRx,
PrevBytesTx,
PrevErrorsHard,
PrevErrorsSoft;
#else
static unsigned int NetIntBlocksRx,
NetIntBlocksTx,
NetIntBytesRx,
NetIntBytesTx,
PrevBlocksRx,
PrevBlocksTx,
PrevBytesRx,
PrevBytesTx,
PrevErrorsHard,
PrevErrorsSoft;
#endif
static long DeviceCount = -1,
DviUnit,
LnmIndex = -1,
LnmAttributes;
static unsigned short LogValueLength;
static char LogValue [32],
NetIntDev [NI_DEVICE_MAX*24];
static struct {
short BufferLength;
short ItemCode;
void *BufferPtr;
void *LengthPtr;
}
LnmItems [] =
{
{ sizeof(LnmIndex), LNM$_INDEX, &LnmIndex, 0 },
{ sizeof(LnmAttributes), LNM$_ATTRIBUTES, &LnmAttributes, 0 },
{ sizeof(LogValue)-1, LNM$_STRING, &LogValue, &LogValueLength },
{ 0,0,0,0 }
},
DevScanItems [] =
{
{ sizeof(DcSCOM), DVS$_DEVCLASS, &DcSCOM, 0 },
{ 0,0,0,0 }
},
GetDviItems [] =
{
{ sizeof(DviUnit), DVI$_UNIT, &DviUnit, 0 },
{ 0,0,0,0 }
};
static $DESCRIPTOR (NetIntDsc, "");
static $DESCRIPTOR (LogNameDsc, "HYPERSPI$AGENT_NI");
static $DESCRIPTOR (LnmFileDevDsc, "LNM$FILE_DEV");
int ecnt, status;
unsigned short pword,
retlen;
unsigned long LnmCount,
NetIntErrorsHard,
NetIntErrorsSoft;
unsigned long DevScanContext [2];
float tfloat;
char *vptr;
char DevScanBuffer [64],
CountBuffer [512];
struct STRUCT_IOSBLK IOsb;
$DESCRIPTOR (CountDsc, CountBuffer);
$DESCRIPTOR (DevScanDsc, DevScanBuffer);
#ifndef __VAX
#define CASTIT (unsigned __int64)
unsigned __int64 value,
BytesRx,
BytesTx;
#else
#define CASTIT (unsigned long)
unsigned long value,
BytesRx,
BytesTx;
unsigned long QuadWord [2] = { 0, 0 };
#endif
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "CollectNetInt() %s\n", NetIntDev);
if (LnmIndex < 0)
{
/* first call, check for logical name defined network devices */
for (LnmIndex = 0; LnmIndex < NI_DEVICE_MAX; LnmIndex++)
{
status = sys$trnlnm (0, &LnmFileDevDsc, &LogNameDsc, 0, &LnmItems);
if (VMSnok (status) || !(LnmAttributes & LNM$M_EXISTS)) break;
LogValue[LogValueLength] = '\0';
NetIntDsc.dsc$a_pointer = LogValue;
NetIntDsc.dsc$w_length = LogValueLength;
status = sys$assign (&NetIntDsc, &NetIntChan[LnmIndex], 0, 0);
if (VMSnok (status))
{
fprintf (stdout, "[%d] %s %%X%08.08X\n",
__LINE__, LogValue, status);
NetIntCount = 0;
break;
}
if (NetIntDev[0]) strcat (NetIntDev, ",");
strcat (NetIntDev, LogValue);
NetIntCount++;
}
}
if (DeviceCount < 0)
{
/* first call */
DeviceCount = 0;
/* if logical name defined and found devices */
if (NetIntCount) return (NetIntCount);
/* scan system for network devices */
DevScanContext[0] = DevScanContext[1] = 0;
while (NetIntCount < NI_DEVICE_MAX)
{
status = sys$device_scan (&DevScanDsc, &retlen, 0,
&DevScanItems, &DevScanContext);
if (VMSnok (status))
{
if (status == SS$_NOMOREDEV || status == SS$_NOSUCHDEV) break;
fprintf (stdout, "[%d] %%X%08.08X\n", __LINE__, status);
NetIntCount = 0;
break;
}
status = sys$getdviw (0, 0, &DevScanDsc, &GetDviItems, &IOsb,
0, 0, 0, 0);
if (VMSok (status)) status = IOsb.iosb$w_status;
if (VMSnok (status))
{
fprintf (stdout, "[%d] %%X%08.08X\n", __LINE__, status);
NetIntCount = 0;
break;
}
/* if not a template device then continue */
if (DviUnit != 0) continue;
status = sys$assign (&DevScanDsc, &NetIntChan[DeviceCount++], 0, 0);
if (VMSnok (status))
{
if (status == SS$_NOPRIV) continue;
fprintf (stdout, "[%d] %s %%X%08.08X\n",
__LINE__, LogValue, status);
NetIntCount = 0;
break;
}
if (NetIntDev[0]) strcat (NetIntDev, ",");
DevScanBuffer[retlen] = '\0';
strcat (NetIntDev, DevScanBuffer+1);
NetIntCount++;
}
/* first call, just return having assigned channels (perhaps) */
return (NetIntCount);
}
/****************/
/* collect data */
/****************/
NetIntBlocksRx = NetIntBlocksTx =
NetIntBytesRx = NetIntBytesTx =
NetIntErrorsHard = NetIntErrorsSoft = 0;
/* if no devices then just return from here */
if (!NetIntCount) return (NetIntCount);
/* accumulate counts from each device */
for (ecnt = 0; ecnt < NetIntCount; ecnt++)
{
/* if the channel has been deassigned */
if (!NetIntChan[ecnt]) continue;
memset (CountBuffer, 0, sizeof(CountBuffer));
status = sys$qiow (0, NetIntChan[ecnt],
#ifndef __VAX
#define IO$M_RD_64COUNT 0x4000
IO$_SENSEMODE | IO$M_RD_COUNT |
IO$M_RD_64COUNT | IO$M_CTRL,
#else
IO$_SENSEMODE | IO$M_RD_COUNT | IO$M_CTRL,
#endif
&IOsb, 0, 0,
0, &CountDsc, 0, 0, 0, 0);
if (VMSok (status)) status = IOsb.iosb$w_status;
if (VMSnok (status))
{
/* if the interface give problems just disable reporting */
static int ReportCount = 0;
if (ReportCount++ < 64)
fprintf (stdout, "[%d] %%X%08.08X \"%s\"%d\n",
__LINE__, status, NetIntDev, ecnt);
else
{
sys$dassgn (NetIntChan[ecnt]);
NetIntChan[ecnt] = 0;
ReportCount = 0;
}
continue;
}
vptr = CountBuffer;
while (vptr < CountBuffer + IOsb.iosb$w_bcnt)
{
pword = *(unsigned short*)vptr;
vptr += 2;
/* end of list */
if (!pword) break;
/* MSB should be set! */
if (!(pword & 0x8000))
{
fprintf (stdout, "[%d] %04.04X\n", __LINE__, pword);
break;
}
value = 0;
#ifndef __VAX
if ((pword & 0x0fff) < 200)
{
/* quadword value (item number less than 200) */
value = *(unsigned __int64*)vptr;
vptr += 8;
}
else
#endif
if ((pword & 0x6000) == 0x6000)
{
/* longword value */
value = *(unsigned long*)vptr;
vptr += 4;
}
else
if ((pword & 0x6000) == 0x4000)
{
/* word value */
value = *(unsigned short*)vptr;
vptr += 2;
}
else
if ((pword & 0x6000) == 0x2000)
{
/* byte value */
value = *(unsigned char*)vptr;
vptr++;
}
if (pword & 0x1000)
{
/* hw map (?) */
value = *(unsigned long*)vptr;
vptr += 2;
continue;
}
switch (pword & 0x0fff)
{
#ifndef __VAX
/* these look suspiciously like "LANCP SHOW DEVICE /COUNT"! */
case 1 :
/* seconds since last zeroed */
break;
case 2 :
case 6 :
NetIntBytesRx += value;
break;
case 3 :
case 7 :
NetIntBytesTx += value;
break;
case 4 :
case 8 :
NetIntBlocksRx += value;
break;
case 5 :
case 9 :
NetIntBlocksTx += value;
break;
case 12 :
case 13 :
case 14 :
case 15 :
case 16 :
case 17 :
case 18 :
case 19 :
case 30 :
case 21 :
case 22 :
case 23 :
case 24 :
case 27 :
case 28 :
case 29 :
NetIntErrorsSoft += value;
break;
case 25 :
case 26 :
case 33 :
case 34 :
NetIntErrorsHard += value;
break;
#endif
/* more "traditional" counters */
case 1000 /* NMA$C_CTLIN_BRC */ :
case 1002 /* NMA$C_CTLIN_MBY */ :
NetIntBytesRx += value;
break;
case 1001 /* NMA$C_CTLIN_BSN */ :
NetIntBytesTx += value;
break;
case 1010 /* NMA$C_CTLIN_DBR */ :
case 1012 /* NMA$C_CTLIN_MBL */ :
NetIntBlocksRx += value;
break;
case 1011 /* NMA$C_CTLIN_DBS */ :
NetIntBlocksTx += value;
break;
case 1013 /* NMA$C_CTLIN_BID */ :
case 1014 /* NMA$C_CTLIN_BS1 */ :
case 1015 /* NMA$C_CTLIN_BSM */ :
case 1040 /* NMA$C_CTLIN_RBE */ :
case 1041 /* NMA$C_CTLIN_LBE */ :
case 1064 /* NMA$C_CTLIN_OVR */ :
case 1066 /* NMA$C_CTLIN_UBU */ :
NetIntErrorsSoft += value;
break;
case 1060 /* NMA$C_CTLIN_SFL */ :
case 1061 /* NMA$C_CTLIN_CDC */ :
case 1063 /* NMA$C_CTLIN_UFD */ :
case 1062 /* NMA$C_CTLIN_RFL */ :
case 1065 /* NMA$C_CTLIN_SBU */ :
NetIntErrorsHard += value;
break;
default :
}
}
}
if (!PrevBytesRx) PrevBytesRx = NetIntBytesRx;
BytesRx = NetIntBytesRx - PrevBytesRx;
PrevBytesRx = NetIntBytesRx;
if (!PrevBytesTx) PrevBytesTx = NetIntBytesTx;
BytesTx = NetIntBytesTx - PrevBytesTx;
PrevBytesTx = NetIntBytesTx;
PrevErrorsSoft = NetIntErrorsSoft;
PrevErrorsHard = NetIntErrorsHard;
#ifndef __VAX
*(unsigned __int64*)SpiRecord.NetIntRx =
*(unsigned __int64*)SpiRecord.NetIntRx + BytesRx;
if ((unsigned long)BytesRx > SpiRecord.PeakNetIntRx)
SpiRecord.PeakNetIntRx = (unsigned long)BytesRx;
*(unsigned __int64*)SpiRecord.NetIntTx =
*(unsigned __int64*)SpiRecord.NetIntTx + BytesTx;
if ((unsigned long)BytesTx > SpiRecord.PeakNetIntTx)
SpiRecord.PeakNetIntTx = (unsigned long)BytesTx;
if ((unsigned long)(BytesRx + BytesTx) > SpiRecord.PeakNetIntRxTx)
SpiRecord.PeakNetIntRxTx = (unsigned long)(BytesRx + BytesTx);
#else
QuadWord[0] = BytesRx;
status = lib$addx (&QuadWord, &SpiRecord.NetIntRx, &SpiRecord.NetIntRx, 0);
if (VMSnok(status)) exit (status);
if (BytesRx > SpiRecord.PeakNetIntRx) SpiRecord.PeakNetIntRx = BytesRx;
QuadWord[0] = BytesTx;
status = lib$addx (&QuadWord, &SpiRecord.NetIntTx, &SpiRecord.NetIntTx, 0);
if (VMSnok(status)) exit (status);
if (BytesTx > SpiRecord.PeakNetIntTx) SpiRecord.PeakNetIntTx = BytesTx;
if (BytesRx + BytesTx > SpiRecord.PeakNetIntRxTx)
SpiRecord.PeakNetIntRxTx = BytesRx + BytesTx;
#endif
return (NetIntCount);
}
/*****************************************************************************/
/*
*/
void DebugSpiRecord ()
{
int idx;
/*********/
/* begin */
/*********/
fprintf (stdout,
"%02.02d:%02.02d CPU %d %d %d, %d %d MEM %dMb %d%% PAG %dMb %d%%\
PRC %d FLT %d %d, %d %d IO %d %d %d, %d %d %d COM %d MODE",
SpiRecord.Hour,
SpiRecord.Minute,
SpiRecord.NumberOfCPUs,
SpiRecord.PercentCPU,
SpiRecord.PercentUserModeCPU,
SpiRecord.PeakPercentCPU,
SpiRecord.PeakPercentUserModeCPU,
SpiRecord.SystemMemoryMBytes,
SpiRecord.SystemMemoryPercentInUse,
SpiRecord.PageSpaceMBytes,
SpiRecord.PageSpacePercentInUse,
SpiRecord.NumberOfProcesses,
SpiRecord.PageFaults,
SpiRecord.HardPageFaults,
SpiRecord.PeakPageFaults,
SpiRecord.PeakHardPageFaults,
SpiRecord.BufferedIO,
SpiRecord.DirectIO,
SpiRecord.MscpIO,
SpiRecord.PeakBufferedIO,
SpiRecord.PeakDirectIO,
SpiRecord.PeakMscpIO,
SpiRecord.Computable);
for (idx = 0; idx < HYPERSPI_CPU_MODE_COUNT; ++idx)
fprintf (stdout, " %d", SpiRecord.PercentModeCPU[idx]);
fprintf (stdout, "\n");
#ifndef __VAX
fprintf (stdout, "NI %12Lu %12u %12Lu %12u %12u\n",
*(__int64*)SpiRecord.NetIntRx, SpiRecord.PeakNetIntRx,
*(__int64*)SpiRecord.NetIntTx, SpiRecord.PeakNetIntTx,
SpiRecord.PeakNetIntRxTx);
#else
fprintf (stdout, "NI %12u %12u %12u %12u %12u\n",
SpiRecord.NetIntRx, SpiRecord.PeakNetIntRx,
SpiRecord.NetIntTx, SpiRecord.PeakNetIntTx,
SpiRecord.PeakNetIntRxTx);
#endif
}
/*****************************************************************************/
/*
Create a logical name HYPERSPI_AGENT_PID containing the process PID (binary).
*/
AgentPidLogical (boolean CreateLogical)
{
static unsigned long PslUser = PSL$C_USER;
static $DESCRIPTOR (LnmSystemDsc, "LNM$SYSTEM");
static $DESCRIPTOR (PidLogNameDsc, "HYPERSPI_AGENT_PID");
static unsigned long Pid;
static struct
{
unsigned short buf_len;
unsigned short item;
void *buf_addr;
unsigned short *short_ret_len;
}
JpiItems [] =
{
{ sizeof(Pid), JPI$_PID, &Pid, 0 },
{ 0,0,0,0 }
},
LnmPidItem [] =
{
{ sizeof(Pid), LNM$_STRING, &Pid, 0 },
{ 0,0,0,0 }
};
int status;
/*********/
/* begin */
/*********/
if (Debug) fprintf (stdout, "AgentPidLogical()\n");
if (CreateLogical)
{
atexit (&AgentPidLogicalAtExit);
status = sys$getjpiw (0, 0, 0, &JpiItems, 0, 0, 0);
if (VMSok (status))
status = sys$crelnm (0, &LnmSystemDsc, &PidLogNameDsc, &PslUser,
&LnmPidItem);
if (VMSnok (status)) exit (status);
}
else
sys$dellnm (&LnmSystemDsc, &PidLogNameDsc, &PslUser);
}
/*****************************************************************************/
/*
Executed during image exit (in particular $FORCEX).
*/
void AgentPidLogicalAtExit ()
{
if (Debug) fprintf (stdout, "AgentPidLogicalAtExit()\n");
AgentPidLogical (false);
}
/****************************************************************************/
/*
Does a case-insensitive character-by-character string compare and returns true
if two strings are the same, or false if not. If a maximum number of
characters are specified only those will be compared, if the entire strings
should be compared then specify the number of characters as 0.
*/
boolean strsame
(
char *sptr1,
char *sptr2,
int count
)
{
while (*sptr1 && *sptr2)
{
if (toupper (*sptr1++) != toupper (*sptr2++)) return (false);
if (count > 0)
if (--count == 0) return (true);
}
if (*sptr1 || *sptr2)
return (false);
else
return (true);
}
/****************************************************************************/