A PI System actually consists of many different
subsystems that you can actually inspect if you
take a look at the Services applet. I'll go into Administrative
Tools here in Control Panel, and just launch
the Services applet here. So, just about
all the services begin with the letters P I.
So you, you'll see a
big long list of them sitting in your Class Documentation.
Let's just kind of go over and take a look at some of
these just real briefly and what they do. So, here are the different services
and individually these are --
most of these are subsystems within PI, but
there's different types. There's, some are interfaces, some are major
subsystems, some are subsystems that may or may not appear on your
local machine. So, let's just
go through with a laundry list real quick. We have a Message Subsystem.
That Message Subsystem is responsible for writing
messages to the System Manager's Message Log. The
License Manager: that's what is controlling licenses.
So we, we will take a look, see if you're licensed
properly and, you know, send you the right Error messages if you're not.
You have something called the Update Manager. This Update Manager
is what facilitates real-time
updates to clients. One of the tricks of the
trade for, you know, making sure we can support
hundreds of clients at a time,
dozens or hundreds of copies of ProcessBook or
DataLink that are all updating in real-time. So
it's called the Update Manager. And we're going to look at --
well, we'll look at some of these things briefly as we move, move through the
class. The Base Subsystem maintains the Point Database.
The Snapshot Subsystem maintains the
Snapshot Data. That's the data that's going to the
system in real-time, the current data only, typically,
as compared to the Archive Subsystem
which manages the Archive Data, the
historical data. Again, all of these are different. You'll find
these listed here. Here's the Archive, etc.,
and Snapshot. Now, don't worry if the terms
Snapshot and Archive are unfamiliar. We're going to go into those in much
more detail when we talk about data compression. And we have a Backup
Subsystem. This PI Backup Subsystem is what you use
for doing automated backups if you choose to do those.
We have a Shutdown Subsystem. Ironically, the Shutdown
Subsystem is something that's typically not going to be running.
It only runs when you do a shutdown. It's writing values
that say that the system's been shut
down to all the tags that have been configured to receive those values.
So that's what the Shutdown does. It doesn't shut the system
down, it writes a shutdown message on shutdown.
Now the PI SQL Subsystem is a -- it's essentially
a ODBC OLE DB driver for
the PI Server. So, any kind of
retrievals that are requesting data using SQL --
you know, the Structured Query Language syntax, are going to be
handled through the PI SQL Subsystem. And then this
PI AF Link Subsystem -- let's see if we can
find it in here. . This Link Subsystem is
what's used for maintaining the connection between
the Module Database, the older Asset Database,
and the new Asset Database, AF,
if you've decided to maintain a synchronization
between the two of them. Now, in addition to those
subsystems, we also have a number of interfaces.
We can see them listed here, but we could also see them listed
over here. If we go into Program Files,
and then PIPC. ...there it is. It's under Program Files,
PIPC Interfaces. Now, I'm just going to go through this list,
and I'm, I'm going to ignore some of the extra interfaces
that I've installed on this machine that you may not see on your machine.
So let's go through the standards. There is a Random
Interface that's used for generating just
random numbers and Sinewave numbers, etc.,
for testing purposes. So that can be useful
if you're trying to stage a system for testing purposes.
This is called the Ramp Soak Simulator. That's used for doing,
again, random or normally distributed data
but batch-oriented data. So if you're trying to look at
repeated events, and you need some kind of a randomizer for that,
that's available. Now these last
three - Performance Monitor, Ping, and
the SNMP Basic --
these are basic versions of interfaces that
will allow you to go out and grab IT data,
or IT-oriented data like, for example,
Performance Monitor Basic is going to
retrieve the performance metrics that
you find in Windows. So, if you go into Windows
Administrative Tools, and you look at Performance,
see these statistics, --
let me bring this into the screen here -- these statistics
like in this case, I think we're just looking at page faults per second,
and percent of disc processor, or
percent of processor use -- ...well,
wouldn't it be nice to be able to bring this into PI? Well, we can, through
this Performance Monitor Basic Interface.
We also have
a similar interface for bringing in SNMP
Data. So, SNMP Data can be anything from
router traffic to whether a
printer has toner in it or not. So,
different devices publish their SNMP Data across the web,
and we can go out and retrieve that data using this
SNMP Basic Interface. Now, Ping Basic
is a wonderful little interface that simply sends out a ping
request to different computers in your network or in, in
external networks, and then records the latency as it comes
back. So, it's a great little interface if you want to try
to detect where there are network bottlenecks, or if there's
a, a network outage of some type. Okay?
Now, finally, there are some
other types of
subsystems that you may not find on all of
your systems, but you will find on some. It just
depends on how you've decided to license the system. For example,
we have the Performance Equation Scheduler which is
a calculation engine. It's kind of a,
a, a free-form sig. . .syntax
language that you can use to develop
expressions to do yield accounting or, or anytime
performance calculations. Okay. Now,
don't confuse that with ACE. ACE is our Advanced Computing Engine.
That's a separate product that goes a step
further than just the simple Performance Equation.
Now, the PI Batch Subsystem which I believe we have installed on
this -- ...there we go. PI Batch
Subsystem is for supporting repeated event
tracking. We have a Whole Batch Subsystem for looking at repeated
events, and this is the mechanism that makes that works.
We have this PI Batch Generator Interface. For those people that don't
have a Batch Execution System themselves,
we can generate batch records, you know, these
mul...these repeated event records
based on just some process value that
indicates to us the start and end of a
batch. So that's what we use that for. We use
that with the Batch Subsystem. We have a
Totalizer that is used -- a Totalizer is
really a kind of a misnomer. It, of course, does
totalizations, but, we only call it the Totalizer because that's the most
popular type of, of aggregation.
It's more of a post-processor that does a variety of aggregations,
like averages, standard deviations, min's, max's,
ranges. It can do a whole variety. It's more --
you know what it is? It's more a fill-in-the-blank
than Performance Equations. Performance Equations can do
these same calculations, but you have to write that using
Expression Syntax. With the Totalizer Subsystem
you can do this same work, but
you simply choose items from a User Interface.
So, that's the Totalizer. Now, the PI
Alarm Subsystem is supporting our older
Alarm Package for -- not
sending, but for detecting when certain process conditions
occur, and setting alarm tags
to certain values to indicate there is some kind of an alarm. And, then,
finally, there's the Recalculator, which is typically not
running unless you would like to specifically
go back and recalculate some of our Performance
Equations, some of the calculations. And why would you want to do that?
Well, let's say you've changed some of the inputs,
and that, after those inputs have changed, you need
to go back and recalculate the calculations that were based on those
inputs. That's what the Recalculator does. And, notice,
the Recalculator Subsystem, it's one of the few PI
Subsystems that simply is not set to
automatic start-up, as you can see right here. And that's because it's only
to be used, typically, when you've got some specific
need for recalculation.