Инструментарий для выполнения лабораторных работ / Sampler_new / Samp16 / SDATA

/* -------------------------------------------------------------------- */
/* */
/* FILE : sdata.h */
/* */
/* DESC : Sampler data definition. */
/* */
/* PROJ : CSA\sampler */
/* */
/* CREATED 16.02.98 19:28 by L&M. */
/* MODIFIED 03.02.99 13:27 by A.V. */
/* */
/* */
/* 1995-98 (c) by Leonid Moiseichuk */
/* -------------------------------------------------------------------- */

#ifndef __sdata_h
#define __sdata_h

/* ==========================[ includes ]============================== */

#ifndef __MEM_H
#include <Mem.h>
#endif

#ifndef __STRING_H
#include <String.h>
#endif

#ifndef __DIR_H
#include <Dir.h>
#endif

#ifndef __STDIO_H
#include <StdIO.h>
#endif

#ifndef __timer_h
#include "Timer.h"
#endif

/* ===========================[ defines ]============================== */

typedef const char far* PChar;
typedef unsigned char uchar;
typedef unsigned int uint;
typedef unsigned long ulong;

typedef char FileName[ MAXPATH ];
typedef uchar FileHandle;

#define MAX_FILES 8u
// Maximum 8 files
#define MAX_LINES 52u
// Maximum of sampling lines in a file
#define MAX_CONDS 8u
// Maximum of conditions for each line
#define MAX_ENTRIES (MAX_FILES * MAX_LINES)

/*
-----------------------------------------------------------------------
Size of SamplerList is MAX_CONDS * 9 + 4 ( current 76 bytes ).
We create MAX_ENTRIES SamplerLists :
== > this array will be little 64K
==> Sizeof(SamplerList) * MAX_ENTRIES < 64K
==> MAX_ENTRIES < 862.
Thus, if have 10 sampling files, we can have 86 lines at a each file.
-----------------------------------------------------------------------
*/

/* ===========================[ classes ]============================== */

class FileMgr
{
public :

FileMgr() : Counter(0)
{ memset( Files,0,sizeof(Files) ); }

~FileMgr() {}

FileHandle HandleOf( PChar );


void Print( FILE* Stream ) const;
void Put( FILE* Stream ) const ;
void Get( FILE* Stream ) ;

PChar NameOf( FileHandle index ) const;
uint Count () { return Counter; }

private :

FileName Files[ MAX_FILES ];
FileHandle Counter ;

}; // Class FileMgr

inline PChar FileMgr :: NameOf( FileHandle index ) const
{
return (index && index<=Counter ? PChar(Files[index-1]) : NULL);
}



class Locate
{
public :

Locate() : File(0), Line(0)
{}

Locate( FileHandle file, uint line ) : File(file), Line(line)
{}

int operator==( const Locate& aTest ) const
{ return (File==aTest.File && Line==aTest.Line); }

int operator <( const Locate& aTest ) const
{ return ( File<aTest.File ? 1 : (File==aTest.File && Line<aTest.Line) ); }

void operator =( const Locate& aSet )
{
File = aSet.File ;
Line = aSet.Line ;
}

void Print( FILE* Stream ) const
{ fprintf( Stream, "%2u :%4u",uint(File),Line ); }

void Put( FILE* Stream ) const ;
void Get( FILE* Stream ) ;

operator int() const
{ return File && Line; }

FileHandle FileID () { return File; }
uint LineNo () { return Line; }
protected :

FileHandle File;
uint Line;
}; // Class Locate

/* Inlines */

inline void Locate :: Put( FILE* Stream ) const
{
fwrite (&File,sizeof(File),1,Stream);
fwrite (&Line,sizeof(Line),1,Stream);
}

inline void Locate :: Get( FILE* Stream )
{
fread (&File,sizeof(File),1,Stream);
fread (&Line,sizeof(Line),1,Stream);
}



class SamplerRecord : public Locate
{
public :

SamplerRecord() { Prob = 0; }

void operator += ( const SamplerRecord& forAdd );
void Print( FILE* Stream, TIME ttime, Tscl Scale) const ;
void Put( FILE* Stream ) const ;
void Get( FILE* Stream ) ;

public :

TIME TotalTime ; /* Totals timing */
uint CrossTimes; /* How march times call */
float Prob;
}; // Class SamplerRecord

/* Inlines */

inline void SamplerRecord :: operator += ( const SamplerRecord& forAdd )
{
if ( Line>0 )
{
CrossTimes ++ ;
TotalTime += forAdd.TotalTime ;
}
else
memcpy(this,&forAdd,sizeof(SamplerRecord) );
} // operator +=

inline void SamplerRecord :: Print(FILE* Stream, TIME _ctime, Tscl Scale) const
{
double precTime = 0.0;
TIME corrTime(UINT32(_ctime)*CrossTimes);
if (TotalTime > corrTime)
precTime = TimeAsMicroSeconds(TotalTime - corrTime, Scale);
Locate::Print(Stream);
fprintf( Stream," %19.2lf %12u %6.2lf %17.2lf", precTime, CrossTimes, Prob, precTime/CrossTimes);

} // Print

inline void SamplerRecord :: Put( FILE* Stream ) const
{
Locate :: Put (Stream);
fwrite (&TotalTime,sizeof(TotalTime),1,Stream);
fwrite (&CrossTimes,sizeof(CrossTimes),1,Stream);
}

inline void SamplerRecord :: Get( FILE* Stream )
{
Locate :: Get (Stream);
fread (&TotalTime,sizeof(TotalTime),1,Stream);
fread (&CrossTimes,sizeof(CrossTimes),1,Stream);
}

struct SumOfInProbsInfo{
float Prob;
long CrossTimes;
};
/* --- Class SamplerList --- */
class SamplerList : public Locate
{
public :

SamplerList() : Counter(0), Prob(0), InArcs(0), SubCounter(0), SubEntriesPtr(0)
{ memset( Conditions,0,sizeof(Conditions) ); }

~SamplerList() {}

void Append( const SamplerRecord& rec );
void Print( FILE* Stream, TIME ttime, Tscl Scale) const ;
void Put( FILE* Stream ) const ;
void Get( FILE* Stream ) ;

SamplerRecord* CondOf( uchar idx )
{ return ( idx < Counter ? &(Conditions[idx]) : 0 ); }
uchar Count () { return Counter; }

typedef SamplerList* SmpLstArr[ MAX_ENTRIES]; //IV
SmpLstArr* SubEntriesPtr; //Pointer at Entries member of Access class
uint SubCounter ; //The number of elements in Entries
float Prob;
uint InArcs;
//both are to be initialized in run-time

// void LoadArc(uchar idx, float ProbVal); //IV
SumOfInProbsInfo SumOfInProbs();
private :
SamplerRecord Conditions[ MAX_CONDS ]; /* Refs for some conds to this line */
uchar Counter ; /* Counter for using records */
}; // Class SamplerList

class Storage
{
public :

Storage() : Counter(0)
{}

~Storage() {}

SamplerList* Allocate()
{ return ( Counter<MAX_ENTRIES ? &Space[Counter++] : NULL ); }

private :

SamplerList Space[ MAX_ENTRIES ]; /* The space for allocation */
uint Counter ;
}; // Class Storage


class Access
{
public :

Access() : Counter(0), timeTrue(0), corrNum(0)
{ memset( Entries,0,sizeof(Entries) );}

~Access() {}

SamplerList* Search( const Locate& ) const;
SamplerList* Search( const FileHandle, const uint, uint& ) const;
void Append( SamplerList* );
void Print( FILE* Stream ) const ;

void TrueTime (TIME ttrue);
TIME TrueTime ();
void CorrScale (Tscl Scale);
Tscl CorrScale ();
SamplerList* At (uint idx);
uint Count () { return Counter; }
void MapProbs();

private :

TIME timeTrue; /* Є®а४жЁп ­  Ё§¬ҐаҐ­Ёп ў вЁЄ е */
Tscl corrNum; /* Є®а४жЁп ¬ бив ЎЁа®ў ­Ёп */
SamplerList* Entries[ MAX_ENTRIES ];
uint Counter ;
friend class CallsHandler;
}; // Class Access

inline void Access :: TrueTime (TIME ttrue)
{
timeTrue = ttrue;
}

inline TIME Access :: TrueTime ()
{
return timeTrue ;
}

inline void Access :: CorrScale (Tscl Scale)
{
corrNum = Scale;
}

inline Tscl Access :: CorrScale ()
{
return corrNum ;
}

inline SamplerList* Access :: At (uint idx)
{
return ( idx < Counter ? Entries[idx] : NULL );
}

class CallsHandler
{
public :

CallsHandler();
~CallsHandler();

TIME TrueTime();
void TrueTime (TIME ttrue);
void CorrScale (Tscl Scale);
Tscl CorrScale ();
void Handle( TIME time, PChar File, uint Line );
void Print( FILE* , PChar Prog ) const ;
void Put( FILE* Stream ) const ;
int Get( FILE* Stream ) ;
void PrintCSA( FILE*, PChar Prog ) const ; //IV

operator int() const
{ return (SamplerAccess && SamplerStorage && SamplerFiles); }

public :

Access* SamplerAccess ;
Storage* SamplerStorage;
FileMgr* SamplerFiles ;
SamplerList* LastUsedRec;
}; // Class CallsHandler

inline void CallsHandler :: TrueTime (TIME ttrue)
{
if (SamplerAccess) SamplerAccess->TrueTime(ttrue);
}

inline TIME CallsHandler :: TrueTime ()
{
return ( (SamplerAccess)? SamplerAccess->TrueTime() : 0ul) ;
}

inline void CallsHandler :: CorrScale (Tscl Scale)
{
if (SamplerAccess) SamplerAccess->CorrScale (Scale);
}

inline Tscl CallsHandler :: CorrScale ()
{
return ( (SamplerAccess)? SamplerAccess->CorrScale() : 0) ;
}

#endif // Sentry of __sdata_h