Information Technology Reference
In-Depth Information
In the rest of this section, we first describe the way of capturing the activation
state of machines using software programs (Sec. 4.1). Then, we describe the
standard features for image classification we used (Sec. 4.2).
4.1
Capturing the Activation State
In an electronic computer, we can simulate the capturing of the activation state
by directly observing the status of the memory. The way we are doing this then
is simple. The aim of this phase is to produce an image representing the acti-
vation state of a machine performing a particular “ cognitive task ”, e.g., sorting
a vector or comparing two strings. We exploit the fact that processes perform
cognitive activities ”. We can define here a “ cognitive activity ” as the execution
of a program over input data. Processes are completely represented in memory,
i.e., both programs and data are stored in memory. Then, we can directly take
snapshots of the memory associated with target processes. These snapshots can
be used to build images.
Given a cognitive activity, the procedure for extracting images from this ac-
tivity is then the following:
-
running the process representing the cognitive activity, i.e., the program and
the related input data
-
stopping the process at given states or at given time intervals
τ
-
dumping the memory associated with the process
-
given a fixed height image and the memory dump, read incrementally bytes
of the memory dump and fill the associated RGB pixel with the read values
-
eventually, produce a smoothed image
This simple procedure can produce more images for each process related to a
cognitive activity.
As it is important to explain which part we are using, here we briefly describe
the organization of the process memory (see Fig. 2). The process memory con-
tains: the process control block, the stack, the heap, the data, and the program
text. The process control block (PCB) contains the information about its status,
i.e., the process identification number, the program counter, the registers, the
list of opened files, etc. The stack contains information regarding function calls,
passed arguments, and local variables. The heap contains dynamically allocated
data, e.g., vectors with a length decided at run-time. The data area contains the
statically allocated data, e.g., vectors with fixed length decided at compilation
time. Finally, the text area contains the compiled program.
The relative size of the different memory areas is extremely important. The
PCB is extremely small with respect to the other areas. The fact that it is not
directly observable from an external process is then not relevant. The information
loss can be ignored. The other four areas are instead observable. Yet, in general,
the data areas (the heap and the data area itself) are bigger than the code area.
Thus, a large part of the memory image represents the data areas.
The process memory is then transformed into an image using the following
procedure. Let
M
(
p
) be the memory dump of the process
p
. The memory dump
Search WWH ::




Custom Search