Python.CudaMarkopy.CudaMarkopyCLI Class Reference

CUDA extension to MarkopyCLI. More...

Inheritance diagram for Python.CudaMarkopy.CudaMarkopyCLI:

Collaboration diagram for Python.CudaMarkopy.CudaMarkopyCLI:

Public Member Functions
None	__init__ (self)
def	help (self)
	overload help function to print submodel helps More...
def	parse (self)
def	parse_fail (self)
def	add_arguments (self)
	add -mt/–model_type constructor More...
def	init_post_arguments (self)
def	init_post_arguments (sel)
def	process (self)
	Process parameters for operation. More...
def	stub (self)
def	evaluate (self, str filename)
def	parse_arguments (self)
def	parse_arguments (self)
def	parse_arguments (self)
def	parse_arguments (self)
def	import_model (self, str filename)
	Import a model file. More...
def	import_model (self, str filename)
	Import a model file. More...
def	import_model (self, str filename)
	Import a model file. More...
def	import_model (self, str filename)
	Import a model file. More...
def	train (self, str dataset, str seperator, str output, bool output_forced=False, bool bulk=False)
	Train a model via CLI parameters. More...
def	train (self, str dataset, str seperator, str output, bool output_forced=False, bool bulk=False)
	Train a model via CLI parameters. More...
def	train (self, str dataset, str seperator, str output, bool output_forced=False, bool bulk=False)
	Train a model via CLI parameters. More...
def	train (self, str dataset, str seperator, str output, bool output_forced=False, bool bulk=False)
	Train a model via CLI parameters. More...
def	export (self, str filename)
	Export model to a file. More...
def	export (self, str filename)
	Export model to a file. More...
def	export (self, str filename)
	Export model to a file. More...
def	export (self, str filename)
	Export model to a file. More...
def	generate (self, str wordlist, bool bulk=False)
	Generate strings from the model. More...
def	generate (self, str wordlist, bool bulk=False)
	Generate strings from the model. More...
def	generate (self, str wordlist, bool bulk=False)
	Generate strings from the model. More...
def	generate (self, str wordlist, bool bulk=False)
	Generate strings from the model. More...
def	FastRandomWalk (int count, str wordlist, int minlen, int maxlen)
int	FastRandomWalk (unsigned long int n, const char *wordlistFileName, int minLen=6, int maxLen=12, int threads=20, bool bFileIO=true)
	Random walk on the Matrix-reduced Markov::Model. More...
bool	ConstructMatrix ()
	Construct the related Matrix data for the model. More...
void	DumpJSON ()
	Debug function to dump the model to a JSON file. More...
void	Import (const char *filename)
	Open a file to import with filename, and call bool Model::Import with std::ifstream. More...
bool	Import (std::ifstream *)
	Import a file to construct the model. More...
def	Import (str filename)
bool	Import (std::ifstream *)
	Import a file to construct the model. More...
void	Train (const char *datasetFileName, char delimiter, int threads)
	Train the model with the dataset file. More...
def	Train (str dataset, str seperator, int threads)
std::ifstream *	OpenDatasetFile (const char *filename)
	Open dataset file and return the ifstream pointer. More...
std::ifstream *	OpenDatasetFile (const char *filename)
	Open dataset file and return the ifstream pointer. More...
std::ofstream *	Save (const char *filename)
	Export model to file. More...
std::ofstream *	Save (const char *filename)
	Export model to file. More...
void	Generate (unsigned long int n, const char *wordlistFileName, int minLen=6, int maxLen=12, int threads=20)
	Call Markov::Model::RandomWalk n times, and collect output. More...
def	Generate (int count, str wordlist, int minlen, int maxlen, int threads)
void	Generate (unsigned long int n, const char *wordlistFileName, int minLen=6, int maxLen=12, int threads=20)
	Call Markov::Model::RandomWalk n times, and collect output. More...
void	Buff (const char *str, double multiplier, bool bDontAdjustSelfLoops=true, bool bDontAdjustExtendedLoops=false)
	Buff expression of some characters in the model. More...
void	Buff (const char *str, double multiplier, bool bDontAdjustSelfLoops=true, bool bDontAdjustExtendedLoops=false)
	Buff expression of some characters in the model. More...
char *	RandomWalk (Markov::Random::RandomEngine *randomEngine, int minSetting, int maxSetting, char *buffer)
	Do a random walk on this model. More...
char *	RandomWalk (Markov::Random::RandomEngine *randomEngine, int minSetting, int maxSetting, char *buffer)
	Do a random walk on this model. More...
void	AdjustEdge (const char *payload, long int occurrence)
	Adjust the model with a single string. More...
void	AdjustEdge (const char *payload, long int occurrence)
	Adjust the model with a single string. More...
bool	Export (std::ofstream *)
	Export a file of the model. More...
bool	Export (const char *filename)
	Open a file to export with filename, and call bool Model::Export with std::ofstream. More...
def	Export (str filename)
bool	Export (std::ofstream *)
	Export a file of the model. More...
bool	Export (const char *filename)
	Open a file to export with filename, and call bool Model::Export with std::ofstream. More...
Node< char > *	StarterNode ()
	Return starter Node. More...
Node< char > *	StarterNode ()
	Return starter Node. More...
std::vector< Edge< char > * > *	Edges ()
	Return a vector of all the edges in the model. More...
std::vector< Edge< char > * > *	Edges ()
	Return a vector of all the edges in the model. More...
std::map< char, Node< char > * > *	Nodes ()
	Return starter Node. More...
std::map< char, Node< char > * > *	Nodes ()
	Return starter Node. More...
void	OptimizeEdgeOrder ()
	Sort edges of all nodes in the model ordered by edge weights. More...
void	OptimizeEdgeOrder ()
	Sort edges of all nodes in the model ordered by edge weights. More...
def	add_arguments (self)
def	init_post_arguments (self)
def	parse_arguments (self)
def	parse_arguments (self)
def	import_model (self, str filename)
	Import a model file. More...
def	import_model (self, str filename)
	Import a model file. More...
def	train (self, str dataset, str seperator, str output, bool output_forced=False, bool bulk=False)
	Train a model via CLI parameters. More...
def	train (self, str dataset, str seperator, str output, bool output_forced=False, bool bulk=False)
	Train a model via CLI parameters. More...
def	export (self, str filename)
	Export model to a file. More...
def	export (self, str filename)
	Export model to a file. More...
def	generate (self, str wordlist, bool bulk=False)
	Generate strings from the model. More...
def	generate (self, str wordlist, bool bulk=False)
	Generate strings from the model. More...
def	FastRandomWalk (int count, str wordlist, int minlen, int maxlen)
int	FastRandomWalk (unsigned long int n, const char *wordlistFileName, int minLen=6, int maxLen=12, int threads=20, bool bFileIO=true)
	Random walk on the Matrix-reduced Markov::Model. More...
__host__ void	FastRandomWalk (unsigned long int n, const char *wordlistFileName, int minLen, int maxLen, bool bFileIO, bool bInfinite)
	Random walk on the Matrix-reduced Markov::Model. More...
int	FastRandomWalk (unsigned long int n, const char *wordlistFileName, int minLen=6, int maxLen=12, int threads=20, bool bFileIO=true)
	Random walk on the Matrix-reduced Markov::Model. More...
bool	ConstructMatrix ()
	Construct the related Matrix data for the model. More...
bool	ConstructMatrix ()
	Construct the related Matrix data for the model. More...
void	DumpJSON ()
	Debug function to dump the model to a JSON file. More...
void	DumpJSON ()
	Debug function to dump the model to a JSON file. More...
void	Import (const char *filename)
	Open a file to import with filename, and call bool Model::Import with std::ifstream. More...
bool	Import (std::ifstream *)
	Import a file to construct the model. More...
void	Import (const char *filename)
	Open a file to import with filename, and call bool Model::Import with std::ifstream. More...
bool	Import (std::ifstream *)
	Import a file to construct the model. More...
void	Train (const char *datasetFileName, char delimiter, int threads)
	Train the model with the dataset file. More...
void	Train (const char *datasetFileName, char delimiter, int threads)
	Train the model with the dataset file. More...
std::ifstream *	OpenDatasetFile (const char *filename)
	Open dataset file and return the ifstream pointer. More...
std::ifstream *	OpenDatasetFile (const char *filename)
	Open dataset file and return the ifstream pointer. More...
std::ofstream *	Save (const char *filename)
	Export model to file. More...
std::ofstream *	Save (const char *filename)
	Export model to file. More...
void	Generate (unsigned long int n, const char *wordlistFileName, int minLen=6, int maxLen=12, int threads=20)
	Call Markov::Model::RandomWalk n times, and collect output. More...
void	Generate (unsigned long int n, const char *wordlistFileName, int minLen=6, int maxLen=12, int threads=20)
	Call Markov::Model::RandomWalk n times, and collect output. More...
void	Buff (const char *str, double multiplier, bool bDontAdjustSelfLoops=true, bool bDontAdjustExtendedLoops=false)
	Buff expression of some characters in the model. More...
void	Buff (const char *str, double multiplier, bool bDontAdjustSelfLoops=true, bool bDontAdjustExtendedLoops=false)
	Buff expression of some characters in the model. More...
char *	RandomWalk (Markov::Random::RandomEngine *randomEngine, int minSetting, int maxSetting, char *buffer)
	Do a random walk on this model. More...
char *	RandomWalk (Markov::Random::RandomEngine *randomEngine, int minSetting, int maxSetting, char *buffer)
	Do a random walk on this model. More...
void	AdjustEdge (const char *payload, long int occurrence)
	Adjust the model with a single string. More...
void	AdjustEdge (const char *payload, long int occurrence)
	Adjust the model with a single string. More...
bool	Export (std::ofstream *)
	Export a file of the model. More...
bool	Export (const char *filename)
	Open a file to export with filename, and call bool Model::Export with std::ofstream. More...
bool	Export (std::ofstream *)
	Export a file of the model. More...
bool	Export (const char *filename)
	Open a file to export with filename, and call bool Model::Export with std::ofstream. More...
Node< char > *	StarterNode ()
	Return starter Node. More...
Node< char > *	StarterNode ()
	Return starter Node. More...
std::vector< Edge< char > * > *	Edges ()
	Return a vector of all the edges in the model. More...
std::vector< Edge< char > * > *	Edges ()
	Return a vector of all the edges in the model. More...
std::map< char, Node< char > * > *	Nodes ()
	Return starter Node. More...
std::map< char, Node< char > * > *	Nodes ()
	Return starter Node. More...
void	OptimizeEdgeOrder ()
	Sort edges of all nodes in the model ordered by edge weights. More...
void	OptimizeEdgeOrder ()
	Sort edges of all nodes in the model ordered by edge weights. More...
__host__ void	MigrateMatrix ()
	Migrate the class members to the VRAM. More...
__host__ void	FlattenMatrix ()
	Flatten migrated matrix from 2d to 1d. More...

Static Public Member Functions
def	check_import_path (str filename)
	check import path for validity More...
def	check_import_path (str filename)
	check import path for validity More...
def	check_import_path (str filename)
	check import path for validity More...
def	check_import_path (str filename)
	check import path for validity More...
def	check_corpus_path (str filename)
	check import path for validity More...
def	check_corpus_path (str filename)
	check import path for validity More...
def	check_corpus_path (str filename)
	check import path for validity More...
def	check_corpus_path (str filename)
	check import path for validity More...
def	check_export_path (str filename)
	check import path for validity More...
def	check_export_path (str filename)
	check import path for validity More...
def	check_export_path (str filename)
	check import path for validity More...
def	check_export_path (str filename)
	check import path for validity More...
def	check_import_path (str filename)
	check import path for validity More...
def	check_import_path (str filename)
	check import path for validity More...
def	check_corpus_path (str filename)
	check import path for validity More...
def	check_corpus_path (str filename)
	check import path for validity More...
def	check_export_path (str filename)
	check import path for validity More...
def	check_export_path (str filename)
	check import path for validity More...
static __host__ void	ListCudaDevices ()
	List CUDA devices in the system. More...

Public Attributes
	args
	cli
	parser
	parser
	parser
	parser
	print_help
	print_help
	print_help
	print_help
	model
	model
	model
	fileIO
	model
	bInfinite
	fileIO
	parser
	parser
	print_help
	print_help

Protected Member Functions
int	FastRandomWalk (unsigned long int n, std::ofstream *wordlist, int minLen=6, int maxLen=12, int threads=20, bool bFileIO=true)
	Random walk on the Matrix-reduced Markov::Model. More...
void	FastRandomWalkPartition (std::mutex *mlock, std::ofstream *wordlist, unsigned long int n, int minLen, int maxLen, bool bFileIO, int threads)
	A single partition of FastRandomWalk event. More...
void	FastRandomWalkThread (std::mutex *mlock, std::ofstream *wordlist, unsigned long int n, int minLen, int maxLen, int id, bool bFileIO)
	A single thread of a single partition of FastRandomWalk. More...
bool	DeallocateMatrix ()
	Deallocate matrix and make it ready for re-construction. More...
int	FastRandomWalk (unsigned long int n, std::ofstream *wordlist, int minLen=6, int maxLen=12, int threads=20, bool bFileIO=true)
	Random walk on the Matrix-reduced Markov::Model. More...
int	FastRandomWalk (unsigned long int n, std::ofstream *wordlist, int minLen=6, int maxLen=12, int threads=20, bool bFileIO=true)
	Random walk on the Matrix-reduced Markov::Model. More...
void	FastRandomWalkPartition (std::mutex *mlock, std::ofstream *wordlist, unsigned long int n, int minLen, int maxLen, bool bFileIO, int threads)
	A single partition of FastRandomWalk event. More...
void	FastRandomWalkPartition (std::mutex *mlock, std::ofstream *wordlist, unsigned long int n, int minLen, int maxLen, bool bFileIO, int threads)
	A single partition of FastRandomWalk event. More...
void	FastRandomWalkThread (std::mutex *mlock, std::ofstream *wordlist, unsigned long int n, int minLen, int maxLen, int id, bool bFileIO)
	A single thread of a single partition of FastRandomWalk. More...
void	FastRandomWalkThread (std::mutex *mlock, std::ofstream *wordlist, unsigned long int n, int minLen, int maxLen, int id, bool bFileIO)
	A single thread of a single partition of FastRandomWalk. More...
bool	DeallocateMatrix ()
	Deallocate matrix and make it ready for re-construction. More...
bool	DeallocateMatrix ()
	Deallocate matrix and make it ready for re-construction. More...
__host__ char *	AllocVRAMOutputBuffer (long int n, long int singleGenMaxLen, long int CUDAKernelGridSize, long int sizePerGrid)
	Allocate the output buffer for kernel operation. More...
__host__ void	LaunchAsyncKernel (int kernelID, int minLen, int maxLen)
__host__ void	prepKernelMemoryChannel (int numberOfStreams)
__host__ void	GatherAsyncKernelOutput (int kernelID, bool bFileIO, std::ofstream &wordlist)

Static Protected Member Functions
static __host__ int	CudaCheckNotifyErr (cudaError_t _status, const char *msg, bool bExit=true)
	Check results of the last operation on GPU. More...
template<typename T >
static __host__ cudaError_t	CudaMalloc2DToFlat (T **dst, int row, int col)
	Malloc a 2D array in device space. More...
template<typename T >
static __host__ cudaError_t	CudaMemcpy2DToFlat (T *dst, T **src, int row, int col)
	Memcpy a 2D array in device space after flattening. More...
template<typename T >
static __host__ cudaError_t	CudaMigrate2DFlat (T **dst, T **src, int row, int col)
	Both malloc and memcpy a 2D array into device VRAM. More...

Protected Attributes
char **	edgeMatrix
	2-D Character array for the edge Matrix (The characters of Nodes) More...
long int **	valueMatrix
	2-d Integer array for the value Matrix (For the weights of Edges) More...
int	matrixSize
	to hold Matrix size More...
char *	matrixIndex
	to hold the Matrix index (To hold the orders of 2-D arrays') More...
long int *	totalEdgeWeights
	Array of the Total Edge Weights. More...
bool	ready
	True when matrix is constructed. False if not. More...
char **	edgeMatrix
	2-D Character array for the edge Matrix (The characters of Nodes) More...
char **	edgeMatrix
	2-D Character array for the edge Matrix (The characters of Nodes) More...
long int **	valueMatrix
	2-d Integer array for the value Matrix (For the weights of Edges) More...
long int **	valueMatrix
	2-d Integer array for the value Matrix (For the weights of Edges) More...
int	matrixSize
	to hold Matrix size More...
int	matrixSize
	to hold Matrix size More...
char *	matrixIndex
	to hold the Matrix index (To hold the orders of 2-D arrays') More...
char *	matrixIndex
	to hold the Matrix index (To hold the orders of 2-D arrays') More...
long int *	totalEdgeWeights
	Array of the Total Edge Weights. More...
long int *	totalEdgeWeights
	Array of the Total Edge Weights. More...
bool	ready
	True when matrix is constructed. False if not. More...
bool	ready
	True when matrix is constructed. False if not. More...

Private Member Functions
def	_generate (self, str wordlist)
	wrapper for generate function. More...
void	TrainThread (Markov::API::Concurrency::ThreadSharedListHandler *listhandler, char delimiter)
	A single thread invoked by the Train function. More...
void	GenerateThread (std::mutex *outputLock, unsigned long int n, std::ofstream *wordlist, int minLen, int maxLen)
	A single thread invoked by the Generate function. More...

Private Attributes
std::ifstream *	datasetFile
std::ofstream *	modelSavefile
	Dataset file input of our system More...
std::ofstream *	outputFile
	File to save model of our system More...
std::map< char, Node< char > * >	nodes
	Map LeftNode is the Nodes NodeValue Map RightNode is the node pointer. More...
Node< char > *	starterNode
	Starter Node of this model. More...
std::vector< Edge< char > * >	edges
	A list of all edges in this model. More...
char *	device_edgeMatrix
	VRAM Address pointer of edge matrix (from modelMatrix.h) More...
long int *	device_valueMatrix
	VRAM Address pointer of value matrix (from modelMatrix.h) More...
char *	device_matrixIndex
	VRAM Address pointer of matrixIndex (from modelMatrix.h) More...
long int *	device_totalEdgeWeights
	VRAM Address pointer of total edge weights (from modelMatrix.h) More...
char **	device_outputBuffer
	RandomWalk results in device. More...
char **	outputBuffer
	RandomWalk results in host. More...
char *	flatEdgeMatrix
	Adding Edge matrix end-to-end and resize to 1-D array for better perfomance on traversing. More...
long int *	flatValueMatrix
	Adding Value matrix end-to-end and resize to 1-D array for better perfomance on traversing. More...
int	cudaBlocks
int	cudaThreads
int	iterationsPerKernelThread
long int	totalOutputPerSync
long int	totalOutputPerKernel
int	numberOfPartitions
int	cudaGridSize
int	cudaMemPerGrid
long int	cudaPerKernelAllocationSize
int	alternatingKernels
unsigned long **	device_seeds
cudaStream_t *	cudastreams

Detailed Description

CUDA extension to MarkopyCLI.

Adds CudaModelMatrixCLI to the interface.

Definition at line 46 of file cudamarkopy.py.

Constructor & Destructor Documentation

__init__()

None Python.CudaMarkopy.CudaMarkopyCLI.__init__

(

self

)

Reimplemented from Python.CudaMarkopy.CudaModelMatrixCLI.

Definition at line 53 of file cudamarkopy.py.

    def __init__(self) -> None:
        "! @brief initialize CLI selector"
        markopy.MarkopyCLI.__init__(self,add_help=False)
        self.parser.epilog+=f"""
        {__file__.split("/")[-1]} -mt CUDA generate trained.mdl -n 500 -w output.txt
            Import trained.mdl, and generate 500 lines to output.txt
        """
 

References Python.Markopy.BaseCLI.parser.

Member Function Documentation

_generate()

def Python.Markopy.BaseCLI._generate (   self, str  wordlist  )

privateinherited

wrapper for generate function.

This can be overloaded by other models

Parameters

wordlist

filename to generate to

Reimplemented in Python.Markopy.ModelMatrixCLI, and Python.CudaMarkopy.CudaModelMatrixCLI.

Definition at line 161 of file base.py.

    def _generate(self, wordlist : str):
        """!
        @brief wrapper for generate function. This can be overloaded by other models
        @param wordlist filename to generate to
        """
        self.model.Generate(int(self.args.count), wordlist, int(self.args.min), int(self.args.max), int(self.args.threads))
 

References Python.CudaMarkopy.CudaMarkopyCLI.args, Python.Markopy.BaseCLI.args, Python.Markopy.MarkopyCLI.args, Python.CudaMarkopy.CudaModelMatrixCLI.model, Python.Markopy.BaseCLI.model, Python.Markopy.ModelMatrixCLI.model, Python.Markopy.MarkovPasswordsCLI.model, and Markov::GUI::MarkovPasswordsGUI.model().

Referenced by Python.Markopy.BaseCLI.generate().

Here is the call graph for this function:

Here is the caller graph for this function:

add_arguments() [1/2]

def Python.CudaMarkopy.CudaModelMatrixCLI.add_arguments (   self )

inherited

Reimplemented from Python.Markopy.AbstractGenerationModelCLI.

Definition at line 67 of file cudammx.py.

    def add_arguments(self):
        super().add_arguments()
        self.parser.add_argument("-if", "--infinite", action="store_true", help="Infinite generation mode")
 

References Python.Markopy.BaseCLI.parser.

Referenced by Python.Markopy.BaseCLI.parse(), and Python.Markopy.MarkopyCLI.parse().

Here is the caller graph for this function:

add_arguments() [2/2]

def Python.Markopy.MarkopyCLI.add_arguments (   self )

inherited

add -mt/–model_type constructor

Reimplemented from Python.Markopy.BaseCLI.

Definition at line 83 of file markopy.py.

    def add_arguments(self):
        """! 
        @brief add -mt/--model_type constructor
        """
        self.parser.add_argument("-mt", "--model_type", default="_MMX", help="Model type to use. Accepted values: MP, MMX")
        self.parser.add_argument("-h", "--help", action="store_true", help="Model type to use. Accepted values: MP, MMX")
        self.parser.add_argument("-ev", "--evaluate", help="Evaluate a models integrity")
        self.parser.add_argument("-evt", "--evaluate_type", help="Evaluation type, model or corpus")
        self.parser.print_help = self.help
 

References Markov::API::CLI::Argparse.help(), Python.CudaMarkopy.CudaMarkopyCLI.help(), Python.Markopy.BaseCLI.help(), Python.Markopy.MarkopyCLI.help(), and Python.Markopy.BaseCLI.parser.

Referenced by Python.Markopy.BaseCLI.parse(), and Python.Markopy.MarkopyCLI.parse().

Here is the call graph for this function:

Here is the caller graph for this function:

AdjustEdge() [1/4]

void Markov::Model< char >::AdjustEdge ( const NodeStorageType *  payload, long int  occurrence  )

inherited

Adjust the model with a single string.

Start from the starter node, and for each character, AdjustEdge the edge EdgeWeight from current node to the next, until NULL character is reached.

Then, update the edge EdgeWeight from current node, to the terminator node.

This function is used for training purposes, as it can be used for adjusting the model with each line of the corpus file.

Example Use: Create an empty model and train it with string: "testdata"

Markov::Model<char> model;
char test[] = "testdata";
model.AdjustEdge(test, 15); 

Parameters

string	- String that is passed from the training, and will be used to AdjustEdge the model with
occurrence	- Occurrence of this string.

Definition at line 109 of file model.h.

                                                                                                 {
    NodeStorageType p = payload[0];
    Markov::Node<NodeStorageType>* curnode = this->starterNode;
    Markov::Edge<NodeStorageType>* e;
    int i = 0;
 
    if (p == 0) return;
    while (p != 0) {
        e = curnode->FindEdge(p);
        if (e == NULL) return;
        e->AdjustEdge(occurrence);
        curnode = e->RightNode();
        p = payload[++i];
    }
 
    e = curnode->FindEdge('\xff');
    e->AdjustEdge(occurrence);
    return;
}

AdjustEdge() [2/4]

void Markov::Model< char >::AdjustEdge ( const NodeStorageType *  payload, long int  occurrence  )

inherited

Adjust the model with a single string.

Start from the starter node, and for each character, AdjustEdge the edge EdgeWeight from current node to the next, until NULL character is reached.

Then, update the edge EdgeWeight from current node, to the terminator node.

This function is used for training purposes, as it can be used for adjusting the model with each line of the corpus file.

Example Use: Create an empty model and train it with string: "testdata"

Markov::Model<char> model;
char test[] = "testdata";
model.AdjustEdge(test, 15); 

Parameters

string	- String that is passed from the training, and will be used to AdjustEdge the model with
occurrence	- Occurrence of this string.

Definition at line 109 of file model.h.

                                                                                                 {
    NodeStorageType p = payload[0];
    Markov::Node<NodeStorageType>* curnode = this->starterNode;
    Markov::Edge<NodeStorageType>* e;
    int i = 0;
 
    if (p == 0) return;
    while (p != 0) {
        e = curnode->FindEdge(p);
        if (e == NULL) return;
        e->AdjustEdge(occurrence);
        curnode = e->RightNode();
        p = payload[++i];
    }
 
    e = curnode->FindEdge('\xff');
    e->AdjustEdge(occurrence);
    return;
}

AdjustEdge() [3/4]

void Markov::Model< char >::AdjustEdge ( const NodeStorageType *  payload, long int  occurrence  )

inherited

Adjust the model with a single string.

Start from the starter node, and for each character, AdjustEdge the edge EdgeWeight from current node to the next, until NULL character is reached.

Then, update the edge EdgeWeight from current node, to the terminator node.

This function is used for training purposes, as it can be used for adjusting the model with each line of the corpus file.

Example Use: Create an empty model and train it with string: "testdata"

Markov::Model<char> model;
char test[] = "testdata";
model.AdjustEdge(test, 15); 

Parameters

string	- String that is passed from the training, and will be used to AdjustEdge the model with
occurrence	- Occurrence of this string.

Definition at line 109 of file model.h.

                                                                                                 {
    NodeStorageType p = payload[0];
    Markov::Node<NodeStorageType>* curnode = this->starterNode;
    Markov::Edge<NodeStorageType>* e;
    int i = 0;
 
    if (p == 0) return;
    while (p != 0) {
        e = curnode->FindEdge(p);
        if (e == NULL) return;
        e->AdjustEdge(occurrence);
        curnode = e->RightNode();
        p = payload[++i];
    }
 
    e = curnode->FindEdge('\xff');
    e->AdjustEdge(occurrence);
    return;
}

AdjustEdge() [4/4]

void Markov::Model< char >::AdjustEdge ( const NodeStorageType *  payload, long int  occurrence  )

inherited

Adjust the model with a single string.

Start from the starter node, and for each character, AdjustEdge the edge EdgeWeight from current node to the next, until NULL character is reached.

Then, update the edge EdgeWeight from current node, to the terminator node.

This function is used for training purposes, as it can be used for adjusting the model with each line of the corpus file.

Example Use: Create an empty model and train it with string: "testdata"

Markov::Model<char> model;
char test[] = "testdata";
model.AdjustEdge(test, 15); 

Parameters

string	- String that is passed from the training, and will be used to AdjustEdge the model with
occurrence	- Occurrence of this string.

Definition at line 109 of file model.h.

                                                                                                 {
    NodeStorageType p = payload[0];
    Markov::Node<NodeStorageType>* curnode = this->starterNode;
    Markov::Edge<NodeStorageType>* e;
    int i = 0;
 
    if (p == 0) return;
    while (p != 0) {
        e = curnode->FindEdge(p);
        if (e == NULL) return;
        e->AdjustEdge(occurrence);
        curnode = e->RightNode();
        p = payload[++i];
    }
 
    e = curnode->FindEdge('\xff');
    e->AdjustEdge(occurrence);
    return;
}

AllocVRAMOutputBuffer()

__host__ char* Markov::API::CUDA::CUDAModelMatrix::AllocVRAMOutputBuffer ( long int  n, long int  singleGenMaxLen, long int  CUDAKernelGridSize, long int  sizePerGrid  )

protectedinherited

Allocate the output buffer for kernel operation.

TODO

Parameters

n	- Number of passwords to generate.
singleGenMaxLen	- maximum string length for a single generation
CUDAKernelGridSize	- Total number of grid members in CUDA kernel
sizePerGrid	- Size to allocate per grid member

Returns

pointer to the allocation on VRAM

Buff() [1/4]

void Markov::API::MarkovPasswords::Buff ( const char *  str, double  multiplier, bool  bDontAdjustSelfLoops = true, bool  bDontAdjustExtendedLoops = false  )

inherited

Buff expression of some characters in the model.

Parameters

str	A string containing all the characters to be buffed
multiplier	A constant value to buff the nodes with.
bDontAdjustSelfEdges	Do not adjust weights if target node is same as source node
bDontAdjustExtendedLoops	Do not adjust if both source and target nodes are in first parameter

Definition at line 153 of file markovPasswords.cpp.

                                                                                                                               {
    std::string buffstr(str);
    std::map< char, Node< char > * > *nodes;
    std::map< char, Edge< char > * > *edges;
    nodes = this->Nodes();
    int i=0;
    for (auto const& [repr, node] : *nodes){
        edges = node->Edges();
        for (auto const& [targetrepr, edge] : *edges){
            if(buffstr.find(targetrepr)!= std::string::npos){
                if(bDontAdjustSelfLoops && repr==targetrepr) continue;
                if(bDontAdjustExtendedLoops){
                    if(buffstr.find(repr)!= std::string::npos){
                        continue;
                    }
                }
                long int weight = edge->EdgeWeight();
                weight = weight*multiplier;     
                edge->AdjustEdge(weight);
            }
 
        }
        i++;
    }
 
    this->OptimizeEdgeOrder();
}

References Markov::Edge< NodeStorageType >::AdjustEdge(), Markov::Node< storageType >::Edges(), Markov::Edge< NodeStorageType >::EdgeWeight(), Markov::Model< NodeStorageType >::Nodes(), and Markov::Model< NodeStorageType >::OptimizeEdgeOrder().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

Buff() [2/4]

void Markov::API::MarkovPasswords::Buff ( const char *  str, double  multiplier, bool  bDontAdjustSelfLoops = true, bool  bDontAdjustExtendedLoops = false  )

inherited

Buff expression of some characters in the model.

Parameters

str	A string containing all the characters to be buffed
multiplier	A constant value to buff the nodes with.
bDontAdjustSelfEdges	Do not adjust weights if target node is same as source node
bDontAdjustExtendedLoops	Do not adjust if both source and target nodes are in first parameter

Definition at line 153 of file markovPasswords.cpp.

                                                                                                                               {
    std::string buffstr(str);
    std::map< char, Node< char > * > *nodes;
    std::map< char, Edge< char > * > *edges;
    nodes = this->Nodes();
    int i=0;
    for (auto const& [repr, node] : *nodes){
        edges = node->Edges();
        for (auto const& [targetrepr, edge] : *edges){
            if(buffstr.find(targetrepr)!= std::string::npos){
                if(bDontAdjustSelfLoops && repr==targetrepr) continue;
                if(bDontAdjustExtendedLoops){
                    if(buffstr.find(repr)!= std::string::npos){
                        continue;
                    }
                }
                long int weight = edge->EdgeWeight();
                weight = weight*multiplier;     
                edge->AdjustEdge(weight);
            }
 
        }
        i++;
    }
 
    this->OptimizeEdgeOrder();
}

References Markov::Edge< NodeStorageType >::AdjustEdge(), Markov::Node< storageType >::Edges(), Markov::Edge< NodeStorageType >::EdgeWeight(), Markov::Model< NodeStorageType >::Nodes(), and Markov::Model< NodeStorageType >::OptimizeEdgeOrder().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

Buff() [3/4]

void Markov::API::MarkovPasswords::Buff ( const char *  str, double  multiplier, bool  bDontAdjustSelfLoops = true, bool  bDontAdjustExtendedLoops = false  )

inherited

Buff expression of some characters in the model.

Parameters

str	A string containing all the characters to be buffed
multiplier	A constant value to buff the nodes with.
bDontAdjustSelfEdges	Do not adjust weights if target node is same as source node
bDontAdjustExtendedLoops	Do not adjust if both source and target nodes are in first parameter

Definition at line 153 of file markovPasswords.cpp.

                                                                                                                               {
    std::string buffstr(str);
    std::map< char, Node< char > * > *nodes;
    std::map< char, Edge< char > * > *edges;
    nodes = this->Nodes();
    int i=0;
    for (auto const& [repr, node] : *nodes){
        edges = node->Edges();
        for (auto const& [targetrepr, edge] : *edges){
            if(buffstr.find(targetrepr)!= std::string::npos){
                if(bDontAdjustSelfLoops && repr==targetrepr) continue;
                if(bDontAdjustExtendedLoops){
                    if(buffstr.find(repr)!= std::string::npos){
                        continue;
                    }
                }
                long int weight = edge->EdgeWeight();
                weight = weight*multiplier;     
                edge->AdjustEdge(weight);
            }
 
        }
        i++;
    }
 
    this->OptimizeEdgeOrder();
}

References Markov::Edge< NodeStorageType >::AdjustEdge(), Markov::Node< storageType >::Edges(), Markov::Edge< NodeStorageType >::EdgeWeight(), Markov::Model< NodeStorageType >::Nodes(), and Markov::Model< NodeStorageType >::OptimizeEdgeOrder().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

Buff() [4/4]

void Markov::API::MarkovPasswords::Buff ( const char *  str, double  multiplier, bool  bDontAdjustSelfLoops = true, bool  bDontAdjustExtendedLoops = false  )

inherited

Buff expression of some characters in the model.

Parameters

str	A string containing all the characters to be buffed
multiplier	A constant value to buff the nodes with.
bDontAdjustSelfEdges	Do not adjust weights if target node is same as source node
bDontAdjustExtendedLoops	Do not adjust if both source and target nodes are in first parameter

Definition at line 153 of file markovPasswords.cpp.

                                                                                                                               {
    std::string buffstr(str);
    std::map< char, Node< char > * > *nodes;
    std::map< char, Edge< char > * > *edges;
    nodes = this->Nodes();
    int i=0;
    for (auto const& [repr, node] : *nodes){
        edges = node->Edges();
        for (auto const& [targetrepr, edge] : *edges){
            if(buffstr.find(targetrepr)!= std::string::npos){
                if(bDontAdjustSelfLoops && repr==targetrepr) continue;
                if(bDontAdjustExtendedLoops){
                    if(buffstr.find(repr)!= std::string::npos){
                        continue;
                    }
                }
                long int weight = edge->EdgeWeight();
                weight = weight*multiplier;     
                edge->AdjustEdge(weight);
            }
 
        }
        i++;
    }
 
    this->OptimizeEdgeOrder();
}

References Markov::Edge< NodeStorageType >::AdjustEdge(), Markov::Node< storageType >::Edges(), Markov::Edge< NodeStorageType >::EdgeWeight(), Markov::Model< NodeStorageType >::Nodes(), and Markov::Model< NodeStorageType >::OptimizeEdgeOrder().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

check_corpus_path() [1/6]

def Python.Markopy.BaseCLI.check_corpus_path ( str  filename )

staticinherited

check import path for validity

Parameters

filename

filename to check

Definition at line 181 of file base.py.

    def check_corpus_path(filename : str):
        """!
        @brief check import path for validity
        @param filename filename to check
        """
 
        if(not os.path.isfile(filename)):
            return False
        return True
 

Referenced by Python.Markopy.BaseCLI.train().

Here is the caller graph for this function:

check_corpus_path() [2/6]

def Python.Markopy.BaseCLI.check_corpus_path ( str  filename )

staticinherited

check import path for validity

Parameters

filename

filename to check

Definition at line 181 of file base.py.

    def check_corpus_path(filename : str):
        """!
        @brief check import path for validity
        @param filename filename to check
        """
 
        if(not os.path.isfile(filename)):
            return False
        return True
 

Referenced by Python.Markopy.BaseCLI.train().

Here is the caller graph for this function:

check_corpus_path() [3/6]

def Python.Markopy.BaseCLI.check_corpus_path ( str  filename )

staticinherited

check import path for validity

Parameters

filename

filename to check

Definition at line 181 of file base.py.

    def check_corpus_path(filename : str):
        """!
        @brief check import path for validity
        @param filename filename to check
        """
 
        if(not os.path.isfile(filename)):
            return False
        return True
 

Referenced by Python.Markopy.BaseCLI.train().

Here is the caller graph for this function:

check_corpus_path() [4/6]

def Python.Markopy.BaseCLI.check_corpus_path ( str  filename )

staticinherited

check import path for validity

Parameters

filename

filename to check

Definition at line 181 of file base.py.

    def check_corpus_path(filename : str):
        """!
        @brief check import path for validity
        @param filename filename to check
        """
 
        if(not os.path.isfile(filename)):
            return False
        return True
 

Referenced by Python.Markopy.BaseCLI.train().

Here is the caller graph for this function:

check_corpus_path() [5/6]

def Python.Markopy.BaseCLI.check_corpus_path ( str  filename )

staticinherited

check import path for validity

Parameters

filename

filename to check

Definition at line 181 of file base.py.

    def check_corpus_path(filename : str):
        """!
        @brief check import path for validity
        @param filename filename to check
        """
 
        if(not os.path.isfile(filename)):
            return False
        return True
 

Referenced by Python.Markopy.BaseCLI.train().

Here is the caller graph for this function:

check_corpus_path() [6/6]

def Python.Markopy.BaseCLI.check_corpus_path ( str  filename )

staticinherited

check import path for validity

Parameters

filename

filename to check

Definition at line 181 of file base.py.

    def check_corpus_path(filename : str):
        """!
        @brief check import path for validity
        @param filename filename to check
        """
 
        if(not os.path.isfile(filename)):
            return False
        return True
 

Referenced by Python.Markopy.BaseCLI.train().

Here is the caller graph for this function:

check_export_path() [1/6]

def Python.Markopy.BaseCLI.check_export_path ( str  filename )

staticinherited

check import path for validity

Parameters

filename

filename to check

Definition at line 192 of file base.py.

    def check_export_path(filename : str):
        """!
        @brief check import path for validity
        @param filename filename to check
        """
 
        if(filename and os.path.isfile(filename)):
            return True
        return True
 

Referenced by Python.Markopy.BaseCLI.train().

Here is the caller graph for this function:

check_export_path() [2/6]

def Python.Markopy.BaseCLI.check_export_path ( str  filename )

staticinherited

check import path for validity

Parameters

filename

filename to check

Definition at line 192 of file base.py.

    def check_export_path(filename : str):
        """!
        @brief check import path for validity
        @param filename filename to check
        """
 
        if(filename and os.path.isfile(filename)):
            return True
        return True
 

Referenced by Python.Markopy.BaseCLI.train().

Here is the caller graph for this function:

check_export_path() [3/6]

def Python.Markopy.BaseCLI.check_export_path ( str  filename )

staticinherited

check import path for validity

Parameters

filename

filename to check

Definition at line 192 of file base.py.

    def check_export_path(filename : str):
        """!
        @brief check import path for validity
        @param filename filename to check
        """
 
        if(filename and os.path.isfile(filename)):
            return True
        return True
 

Referenced by Python.Markopy.BaseCLI.train().

Here is the caller graph for this function:

check_export_path() [4/6]

def Python.Markopy.BaseCLI.check_export_path ( str  filename )

staticinherited

check import path for validity

Parameters

filename

filename to check

Definition at line 192 of file base.py.

    def check_export_path(filename : str):
        """!
        @brief check import path for validity
        @param filename filename to check
        """
 
        if(filename and os.path.isfile(filename)):
            return True
        return True
 

Referenced by Python.Markopy.BaseCLI.train().

Here is the caller graph for this function:

check_export_path() [5/6]

def Python.Markopy.BaseCLI.check_export_path ( str  filename )

staticinherited

check import path for validity

Parameters

filename

filename to check

Definition at line 192 of file base.py.

    def check_export_path(filename : str):
        """!
        @brief check import path for validity
        @param filename filename to check
        """
 
        if(filename and os.path.isfile(filename)):
            return True
        return True
 

Referenced by Python.Markopy.BaseCLI.train().

Here is the caller graph for this function:

check_export_path() [6/6]

def Python.Markopy.BaseCLI.check_export_path ( str  filename )

staticinherited

check import path for validity

Parameters

filename

filename to check

Definition at line 192 of file base.py.

    def check_export_path(filename : str):
        """!
        @brief check import path for validity
        @param filename filename to check
        """
 
        if(filename and os.path.isfile(filename)):
            return True
        return True
 

Referenced by Python.Markopy.BaseCLI.train().

Here is the caller graph for this function:

check_import_path() [1/6]

def Python.Markopy.BaseCLI.check_import_path ( str  filename )

staticinherited

check import path for validity

Parameters

filename

filename to check

Definition at line 169 of file base.py.

    def check_import_path(filename : str):
        """!
        @brief check import path for validity
        @param filename filename to check
        """
        
        if(not os.path.isfile(filename)):
            return False
        else:
            return True
 

Referenced by Python.Markopy.BaseCLI.import_model().

Here is the caller graph for this function:

check_import_path() [2/6]

def Python.Markopy.BaseCLI.check_import_path ( str  filename )

staticinherited

check import path for validity

Parameters

filename

filename to check

Definition at line 169 of file base.py.

    def check_import_path(filename : str):
        """!
        @brief check import path for validity
        @param filename filename to check
        """
        
        if(not os.path.isfile(filename)):
            return False
        else:
            return True
 

Referenced by Python.Markopy.BaseCLI.import_model().

Here is the caller graph for this function:

check_import_path() [3/6]

def Python.Markopy.BaseCLI.check_import_path ( str  filename )

staticinherited

check import path for validity

Parameters

filename

filename to check

Definition at line 169 of file base.py.

    def check_import_path(filename : str):
        """!
        @brief check import path for validity
        @param filename filename to check
        """
        
        if(not os.path.isfile(filename)):
            return False
        else:
            return True
 

Referenced by Python.Markopy.BaseCLI.import_model().

Here is the caller graph for this function:

check_import_path() [4/6]

def Python.Markopy.BaseCLI.check_import_path ( str  filename )

staticinherited

check import path for validity

Parameters

filename

filename to check

Definition at line 169 of file base.py.

    def check_import_path(filename : str):
        """!
        @brief check import path for validity
        @param filename filename to check
        """
        
        if(not os.path.isfile(filename)):
            return False
        else:
            return True
 

Referenced by Python.Markopy.BaseCLI.import_model().

Here is the caller graph for this function:

check_import_path() [5/6]

def Python.Markopy.BaseCLI.check_import_path ( str  filename )

staticinherited

check import path for validity

Parameters

filename

filename to check

Definition at line 169 of file base.py.

    def check_import_path(filename : str):
        """!
        @brief check import path for validity
        @param filename filename to check
        """
        
        if(not os.path.isfile(filename)):
            return False
        else:
            return True
 

Referenced by Python.Markopy.BaseCLI.import_model().

Here is the caller graph for this function:

check_import_path() [6/6]

def Python.Markopy.BaseCLI.check_import_path ( str  filename )

staticinherited

check import path for validity

Parameters

filename

filename to check

Definition at line 169 of file base.py.

    def check_import_path(filename : str):
        """!
        @brief check import path for validity
        @param filename filename to check
        """
        
        if(not os.path.isfile(filename)):
            return False
        else:
            return True
 

Referenced by Python.Markopy.BaseCLI.import_model().

Here is the caller graph for this function:

ConstructMatrix() [1/3]

bool Markov::API::ModelMatrix::ConstructMatrix ( )

inherited

Construct the related Matrix data for the model.

This operation can be used after importing/training to allocate and populate the matrix content.

this will initialize: char** edgeMatrix -> a 2D array of mapping left and right connections of each edge. long int **valueMatrix -> a 2D array representing the edge weights. int matrixSize -> Size of the matrix, aka total number of nodes. char* matrixIndex -> order of nodes in the model long int *totalEdgeWeights -> total edge weights of each Node.

Returns

True if constructed. False if already construced.

Definition at line 31 of file modelMatrix.cpp.

                                          {
    if(this->ready) return false;
    this->matrixSize = this->StarterNode()->edgesV.size() + 2;
 
    this->matrixIndex = new char[this->matrixSize];
    this->totalEdgeWeights = new long int[this->matrixSize];
 
    this->edgeMatrix = new char*[this->matrixSize];
    for(int i=0;i<this->matrixSize;i++){
        this->edgeMatrix[i] = new char[this->matrixSize];
    }
    this->valueMatrix = new long int*[this->matrixSize];
    for(int i=0;i<this->matrixSize;i++){
        this->valueMatrix[i] = new long int[this->matrixSize];
    }
    std::map< char, Node< char > * > *nodes;
    nodes = this->Nodes();
    int i=0;
    for (auto const& [repr, node] : *nodes){
        if(repr!=0) this->matrixIndex[i] = repr;
        else this->matrixIndex[i] = 199;
        this->totalEdgeWeights[i] = node->TotalEdgeWeights();
        for(int j=0;j<this->matrixSize;j++){
            char val = node->NodeValue();
            if(val < 0){
                for(int k=0;k<this->matrixSize;k++){
                    this->valueMatrix[i][k] = 0;
                    this->edgeMatrix[i][k] = 255;
                }
                break;
            }
            else if(node->NodeValue() == 0 && j>(this->matrixSize-3)){
                this->valueMatrix[i][j] = 0;
                this->edgeMatrix[i][j] = 255;
            }else if(j==(this->matrixSize-1)) {
                this->valueMatrix[i][j] = 0;
                this->edgeMatrix[i][j] = 255;
            }else{
                this->valueMatrix[i][j] = node->edgesV[j]->EdgeWeight();
                this->edgeMatrix[i][j]  = node->edgesV[j]->RightNode()->NodeValue();
            }
 
        }
        i++;
    }
    this->ready = true;
    return true;
    //this->DumpJSON();
}

References Markov::API::ModelMatrix::edgeMatrix, Markov::Edge< NodeStorageType >::EdgeWeight(), Markov::API::ModelMatrix::matrixIndex, Markov::API::ModelMatrix::matrixSize, Markov::Model< NodeStorageType >::Nodes(), Markov::Node< storageType >::NodeValue(), Markov::API::ModelMatrix::ready, Markov::Edge< NodeStorageType >::RightNode(), Markov::Model< NodeStorageType >::StarterNode(), Markov::API::ModelMatrix::totalEdgeWeights, Markov::Node< storageType >::TotalEdgeWeights(), and Markov::API::ModelMatrix::valueMatrix.

Referenced by Markov::Markopy::CUDA::BOOST_PYTHON_MODULE(), Markov::Markopy::BOOST_PYTHON_MODULE(), Markov::API::ModelMatrix::Import(), and Markov::API::ModelMatrix::Train().

Here is the call graph for this function:

Here is the caller graph for this function:

ConstructMatrix() [2/3]

bool Markov::API::ModelMatrix::ConstructMatrix ( )

inherited

Construct the related Matrix data for the model.

This operation can be used after importing/training to allocate and populate the matrix content.

this will initialize: char** edgeMatrix -> a 2D array of mapping left and right connections of each edge. long int **valueMatrix -> a 2D array representing the edge weights. int matrixSize -> Size of the matrix, aka total number of nodes. char* matrixIndex -> order of nodes in the model long int *totalEdgeWeights -> total edge weights of each Node.

Returns

True if constructed. False if already construced.

Definition at line 31 of file modelMatrix.cpp.

                                          {
    if(this->ready) return false;
    this->matrixSize = this->StarterNode()->edgesV.size() + 2;
 
    this->matrixIndex = new char[this->matrixSize];
    this->totalEdgeWeights = new long int[this->matrixSize];
 
    this->edgeMatrix = new char*[this->matrixSize];
    for(int i=0;i<this->matrixSize;i++){
        this->edgeMatrix[i] = new char[this->matrixSize];
    }
    this->valueMatrix = new long int*[this->matrixSize];
    for(int i=0;i<this->matrixSize;i++){
        this->valueMatrix[i] = new long int[this->matrixSize];
    }
    std::map< char, Node< char > * > *nodes;
    nodes = this->Nodes();
    int i=0;
    for (auto const& [repr, node] : *nodes){
        if(repr!=0) this->matrixIndex[i] = repr;
        else this->matrixIndex[i] = 199;
        this->totalEdgeWeights[i] = node->TotalEdgeWeights();
        for(int j=0;j<this->matrixSize;j++){
            char val = node->NodeValue();
            if(val < 0){
                for(int k=0;k<this->matrixSize;k++){
                    this->valueMatrix[i][k] = 0;
                    this->edgeMatrix[i][k] = 255;
                }
                break;
            }
            else if(node->NodeValue() == 0 && j>(this->matrixSize-3)){
                this->valueMatrix[i][j] = 0;
                this->edgeMatrix[i][j] = 255;
            }else if(j==(this->matrixSize-1)) {
                this->valueMatrix[i][j] = 0;
                this->edgeMatrix[i][j] = 255;
            }else{
                this->valueMatrix[i][j] = node->edgesV[j]->EdgeWeight();
                this->edgeMatrix[i][j]  = node->edgesV[j]->RightNode()->NodeValue();
            }
 
        }
        i++;
    }
    this->ready = true;
    return true;
    //this->DumpJSON();
}

References Markov::API::ModelMatrix::edgeMatrix, Markov::Edge< NodeStorageType >::EdgeWeight(), Markov::API::ModelMatrix::matrixIndex, Markov::API::ModelMatrix::matrixSize, Markov::Model< NodeStorageType >::Nodes(), Markov::Node< storageType >::NodeValue(), Markov::API::ModelMatrix::ready, Markov::Edge< NodeStorageType >::RightNode(), Markov::Model< NodeStorageType >::StarterNode(), Markov::API::ModelMatrix::totalEdgeWeights, Markov::Node< storageType >::TotalEdgeWeights(), and Markov::API::ModelMatrix::valueMatrix.

Referenced by Markov::Markopy::CUDA::BOOST_PYTHON_MODULE(), Markov::Markopy::BOOST_PYTHON_MODULE(), Markov::API::ModelMatrix::Import(), and Markov::API::ModelMatrix::Train().

Here is the call graph for this function:

Here is the caller graph for this function:

ConstructMatrix() [3/3]

bool Markov::API::ModelMatrix::ConstructMatrix ( )

inherited

Construct the related Matrix data for the model.

This operation can be used after importing/training to allocate and populate the matrix content.

this will initialize: char** edgeMatrix -> a 2D array of mapping left and right connections of each edge. long int **valueMatrix -> a 2D array representing the edge weights. int matrixSize -> Size of the matrix, aka total number of nodes. char* matrixIndex -> order of nodes in the model long int *totalEdgeWeights -> total edge weights of each Node.

Returns

True if constructed. False if already construced.

Definition at line 31 of file modelMatrix.cpp.

                                          {
    if(this->ready) return false;
    this->matrixSize = this->StarterNode()->edgesV.size() + 2;
 
    this->matrixIndex = new char[this->matrixSize];
    this->totalEdgeWeights = new long int[this->matrixSize];
 
    this->edgeMatrix = new char*[this->matrixSize];
    for(int i=0;i<this->matrixSize;i++){
        this->edgeMatrix[i] = new char[this->matrixSize];
    }
    this->valueMatrix = new long int*[this->matrixSize];
    for(int i=0;i<this->matrixSize;i++){
        this->valueMatrix[i] = new long int[this->matrixSize];
    }
    std::map< char, Node< char > * > *nodes;
    nodes = this->Nodes();
    int i=0;
    for (auto const& [repr, node] : *nodes){
        if(repr!=0) this->matrixIndex[i] = repr;
        else this->matrixIndex[i] = 199;
        this->totalEdgeWeights[i] = node->TotalEdgeWeights();
        for(int j=0;j<this->matrixSize;j++){
            char val = node->NodeValue();
            if(val < 0){
                for(int k=0;k<this->matrixSize;k++){
                    this->valueMatrix[i][k] = 0;
                    this->edgeMatrix[i][k] = 255;
                }
                break;
            }
            else if(node->NodeValue() == 0 && j>(this->matrixSize-3)){
                this->valueMatrix[i][j] = 0;
                this->edgeMatrix[i][j] = 255;
            }else if(j==(this->matrixSize-1)) {
                this->valueMatrix[i][j] = 0;
                this->edgeMatrix[i][j] = 255;
            }else{
                this->valueMatrix[i][j] = node->edgesV[j]->EdgeWeight();
                this->edgeMatrix[i][j]  = node->edgesV[j]->RightNode()->NodeValue();
            }
 
        }
        i++;
    }
    this->ready = true;
    return true;
    //this->DumpJSON();
}

References Markov::API::ModelMatrix::edgeMatrix, Markov::Edge< NodeStorageType >::EdgeWeight(), Markov::API::ModelMatrix::matrixIndex, Markov::API::ModelMatrix::matrixSize, Markov::Model< NodeStorageType >::Nodes(), Markov::Node< storageType >::NodeValue(), Markov::API::ModelMatrix::ready, Markov::Edge< NodeStorageType >::RightNode(), Markov::Model< NodeStorageType >::StarterNode(), Markov::API::ModelMatrix::totalEdgeWeights, Markov::Node< storageType >::TotalEdgeWeights(), and Markov::API::ModelMatrix::valueMatrix.

Referenced by Markov::Markopy::CUDA::BOOST_PYTHON_MODULE(), Markov::Markopy::BOOST_PYTHON_MODULE(), Markov::API::ModelMatrix::Import(), and Markov::API::ModelMatrix::Train().

Here is the call graph for this function:

Here is the caller graph for this function:

CudaCheckNotifyErr()

__host__ int Markov::API::CUDA::CUDADeviceController::CudaCheckNotifyErr ( cudaError_t  _status, const char *  msg, bool  bExit = true  )

staticprotectedinherited

Check results of the last operation on GPU.

Check the status returned from cudaMalloc/cudaMemcpy to find failures.

If a failure occurs, its assumed beyond redemption, and exited.

Parameters

_status	Cuda error status to check
msg	Message to print in case of a failure

Returns

0 if successful, 1 if failure. Example output:

char *da, a = "test";
cudastatus = cudaMalloc((char **)&da, 5*sizeof(char*));
CudaCheckNotifyErr(cudastatus, "Failed to allocate VRAM for *da.\n");

Definition at line 32 of file cudaDeviceController.cu.

                                                                                                                       {
        if (_status != cudaSuccess) {
            std::cerr << "\033[1;31m" << msg  << " -> " << cudaGetErrorString(_status)  << " ("<< _status << ")" << "\033[0m" << "\n";
            
            if(bExit) {
                cudaDeviceReset();
                exit(1);
            }
        }
        return 0;
    }

CudaMalloc2DToFlat()

template<typename T >

static __host__ cudaError_t Markov::API::CUDA::CUDADeviceController::CudaMalloc2DToFlat ( T **  dst, int  row, int  col  )

inlinestaticprotectedinherited

Malloc a 2D array in device space.

This function will allocate enough space on VRAM for flattened 2D array.

Parameters

dst	destination pointer
row	row size of the 2d array
col	column size of the 2d array

Returns

cudaError_t status of the cudaMalloc operation

Example output:

cudaError_t cudastatus;
char* dst;
cudastatus = CudaMalloc2DToFlat<char>(&dst, 5, 15);
if(cudastatus!=cudaSuccess){
    CudaCheckNotifyErr(cudastatus, "  CudaMalloc2DToFlat Failed.", false);
}

Definition at line 75 of file cudaDeviceController.h.

                                                                                 {
            cudaError_t cudastatus = cudaMalloc((T **)dst, row*col*sizeof(T));
            CudaCheckNotifyErr(cudastatus, "cudaMalloc Failed.", false);
            return cudastatus;
        }

References Markov::API::CUDA::CUDADeviceController::CudaMigrate2DFlat().

Here is the call graph for this function:

CudaMemcpy2DToFlat()

template<typename T >

static __host__ cudaError_t Markov::API::CUDA::CUDADeviceController::CudaMemcpy2DToFlat ( T *  dst, T **  src, int  row, int  col  )

inlinestaticprotectedinherited

Memcpy a 2D array in device space after flattening.

Resulting buffer will not be true 2D array.

Parameters

dst	destination pointer
rc	source pointer
row	row size of the 2d array
col	column size of the 2d array

Returns

cudaError_t status of the cudaMalloc operation

Example output:

cudaError_t cudastatus;
char* dst;
cudastatus = CudaMalloc2DToFlat<char>(&dst, 5, 15);
CudaCheckNotifyErr(cudastatus, "  CudaMalloc2DToFlat Failed.", false);
cudastatus = CudaMemcpy2DToFlat<char>(*dst,src,15,15);
CudaCheckNotifyErr(cudastatus, "  CudaMemcpy2DToFlat Failed.", false);

Definition at line 103 of file cudaDeviceController.h.

                                                                                         {
            T* tempbuf = new T[row*col];
            for(int i=0;i<row;i++){
                memcpy(&(tempbuf[row*i]), src[i], col);
            }
            return cudaMemcpy(dst, tempbuf, row*col*sizeof(T), cudaMemcpyHostToDevice);
            
        }

References Markov::API::CUDA::CUDADeviceController::CudaMigrate2DFlat().

Here is the call graph for this function:

CudaMigrate2DFlat()

template<typename T >

static __host__ cudaError_t Markov::API::CUDA::CUDADeviceController::CudaMigrate2DFlat ( T **  dst, T **  src, int  row, int  col  )

inlinestaticprotectedinherited

Both malloc and memcpy a 2D array into device VRAM.

Resulting buffer will not be true 2D array.

Parameters

dst	destination pointer
rc	source pointer
row	row size of the 2d array
col	column size of the 2d array

Returns

cudaError_t status of the cudaMalloc operation

Example output:

cudaError_t cudastatus;
char* dst;
cudastatus = CudaMigrate2DFlat<long int>(
   &dst, this->valueMatrix, this->matrixSize, this->matrixSize);
CudaCheckNotifyErr(cudastatus, "    Cuda failed to initialize value matrix row.");

Definition at line 132 of file cudaDeviceController.h.

                                                                                         {
            cudaError_t cudastatus;
            cudastatus = CudaMalloc2DToFlat<T>(dst, row, col);
            if(cudastatus!=cudaSuccess){
                CudaCheckNotifyErr(cudastatus, "  CudaMalloc2DToFlat Failed.", false);
                return cudastatus;
            }
            cudastatus = CudaMemcpy2DToFlat<T>(*dst,src,row,col);
            CudaCheckNotifyErr(cudastatus, "  CudaMemcpy2DToFlat Failed.", false);
            return cudastatus;
        }

References Markov::API::CUDA::CUDADeviceController::CudaMigrate2DFlat().

Referenced by Markov::API::CUDA::CUDADeviceController::CudaMalloc2DToFlat(), Markov::API::CUDA::CUDADeviceController::CudaMemcpy2DToFlat(), and Markov::API::CUDA::CUDADeviceController::CudaMigrate2DFlat().

Here is the call graph for this function:

Here is the caller graph for this function:

DeallocateMatrix() [1/3]

bool Markov::API::ModelMatrix::DeallocateMatrix ( )

protectedinherited

Deallocate matrix and make it ready for re-construction.

Returns

True if deallocated. False if matrix was not initialized

Definition at line 81 of file modelMatrix.cpp.

                                           {
    if(!this->ready) return false;
    delete[] this->matrixIndex;
    delete[] this->totalEdgeWeights;
 
    for(int i=0;i<this->matrixSize;i++){
        delete[] this->edgeMatrix[i];
    }
    delete[] this->edgeMatrix;
 
    for(int i=0;i<this->matrixSize;i++){
        delete[] this->valueMatrix[i];
    }
    delete[] this->valueMatrix;
 
    this->matrixSize = -1;
    this->ready = false;
    return true;
}

References Markov::API::ModelMatrix::edgeMatrix, Markov::API::ModelMatrix::matrixIndex, Markov::API::ModelMatrix::matrixSize, Markov::API::ModelMatrix::ready, Markov::API::ModelMatrix::totalEdgeWeights, and Markov::API::ModelMatrix::valueMatrix.

Referenced by Markov::API::ModelMatrix::Import(), and Markov::API::ModelMatrix::Train().

Here is the caller graph for this function:

DeallocateMatrix() [2/3]

bool Markov::API::ModelMatrix::DeallocateMatrix ( )

protectedinherited

Deallocate matrix and make it ready for re-construction.

Returns

True if deallocated. False if matrix was not initialized

Definition at line 81 of file modelMatrix.cpp.

                                           {
    if(!this->ready) return false;
    delete[] this->matrixIndex;
    delete[] this->totalEdgeWeights;
 
    for(int i=0;i<this->matrixSize;i++){
        delete[] this->edgeMatrix[i];
    }
    delete[] this->edgeMatrix;
 
    for(int i=0;i<this->matrixSize;i++){
        delete[] this->valueMatrix[i];
    }
    delete[] this->valueMatrix;
 
    this->matrixSize = -1;
    this->ready = false;
    return true;
}

References Markov::API::ModelMatrix::edgeMatrix, Markov::API::ModelMatrix::matrixIndex, Markov::API::ModelMatrix::matrixSize, Markov::API::ModelMatrix::ready, Markov::API::ModelMatrix::totalEdgeWeights, and Markov::API::ModelMatrix::valueMatrix.

Referenced by Markov::API::ModelMatrix::Import(), and Markov::API::ModelMatrix::Train().

Here is the caller graph for this function:

DeallocateMatrix() [3/3]

bool Markov::API::ModelMatrix::DeallocateMatrix ( )

protectedinherited

Deallocate matrix and make it ready for re-construction.

Returns

True if deallocated. False if matrix was not initialized

Definition at line 81 of file modelMatrix.cpp.

                                           {
    if(!this->ready) return false;
    delete[] this->matrixIndex;
    delete[] this->totalEdgeWeights;
 
    for(int i=0;i<this->matrixSize;i++){
        delete[] this->edgeMatrix[i];
    }
    delete[] this->edgeMatrix;
 
    for(int i=0;i<this->matrixSize;i++){
        delete[] this->valueMatrix[i];
    }
    delete[] this->valueMatrix;
 
    this->matrixSize = -1;
    this->ready = false;
    return true;
}

References Markov::API::ModelMatrix::edgeMatrix, Markov::API::ModelMatrix::matrixIndex, Markov::API::ModelMatrix::matrixSize, Markov::API::ModelMatrix::ready, Markov::API::ModelMatrix::totalEdgeWeights, and Markov::API::ModelMatrix::valueMatrix.

Referenced by Markov::API::ModelMatrix::Import(), and Markov::API::ModelMatrix::Train().

Here is the caller graph for this function:

DumpJSON() [1/3]

void Markov::API::ModelMatrix::DumpJSON ( )

inherited

Debug function to dump the model to a JSON file.

Might not work 100%. Not meant for production use.

Definition at line 101 of file modelMatrix.cpp.

                                   {
 
    std::cout << "{\n   \"index\": \"";
    for(int i=0;i<this->matrixSize;i++){
        if(this->matrixIndex[i]=='"') std::cout << "\\\"";
        else if(this->matrixIndex[i]=='\\') std::cout << "\\\\";
        else if(this->matrixIndex[i]==0) std::cout << "\\\\x00";
        else if(i==0) std::cout << "\\\\xff";
        else if(this->matrixIndex[i]=='\n') std::cout << "\\n";
        else std::cout << this->matrixIndex[i];
    }
    std::cout << 
    "\",\n"
    "   \"edgemap\": {\n";
 
    for(int i=0;i<this->matrixSize;i++){
        if(this->matrixIndex[i]=='"') std::cout << "      \"\\\"\": [";
        else if(this->matrixIndex[i]=='\\') std::cout << "      \"\\\\\": [";
        else if(this->matrixIndex[i]==0) std::cout << "      \"\\\\x00\": [";
        else if(this->matrixIndex[i]<0) std::cout << "      \"\\\\xff\": [";
        else std::cout << "      \"" << this->matrixIndex[i] << "\": [";
        for(int j=0;j<this->matrixSize;j++){
            if(this->edgeMatrix[i][j]=='"') std::cout << "\"\\\"\"";
            else if(this->edgeMatrix[i][j]=='\\') std::cout << "\"\\\\\"";
            else if(this->edgeMatrix[i][j]==0) std::cout << "\"\\\\x00\"";
            else if(this->edgeMatrix[i][j]<0) std::cout << "\"\\\\xff\"";
            else if(this->matrixIndex[i]=='\n') std::cout << "\"\\n\"";
            else std::cout << "\"" << this->edgeMatrix[i][j] << "\"";
            if(j!=this->matrixSize-1) std::cout << ", ";
        }
        std::cout << "],\n";
    }
    std::cout << "},\n";
 
    std::cout << "\"   weightmap\": {\n";
    for(int i=0;i<this->matrixSize;i++){
        if(this->matrixIndex[i]=='"') std::cout << "      \"\\\"\": [";
        else if(this->matrixIndex[i]=='\\') std::cout << "      \"\\\\\": [";
        else if(this->matrixIndex[i]==0) std::cout << "      \"\\\\x00\": [";
        else if(this->matrixIndex[i]<0) std::cout << "      \"\\\\xff\": [";
        else std::cout << "      \"" << this->matrixIndex[i] << "\": [";
 
        for(int j=0;j<this->matrixSize;j++){
            std::cout << this->valueMatrix[i][j];
            if(j!=this->matrixSize-1) std::cout << ", ";
        }
        std::cout << "],\n";
    }
    std::cout << "  }\n}\n";
}

References Markov::API::ModelMatrix::edgeMatrix, Markov::API::ModelMatrix::matrixIndex, Markov::API::ModelMatrix::matrixSize, and Markov::API::ModelMatrix::valueMatrix.

Referenced by Markov::Markopy::CUDA::BOOST_PYTHON_MODULE(), and Markov::Markopy::BOOST_PYTHON_MODULE().

Here is the caller graph for this function:

DumpJSON() [2/3]

void Markov::API::ModelMatrix::DumpJSON ( )

inherited

Debug function to dump the model to a JSON file.

Might not work 100%. Not meant for production use.

Definition at line 101 of file modelMatrix.cpp.

                                   {
 
    std::cout << "{\n   \"index\": \"";
    for(int i=0;i<this->matrixSize;i++){
        if(this->matrixIndex[i]=='"') std::cout << "\\\"";
        else if(this->matrixIndex[i]=='\\') std::cout << "\\\\";
        else if(this->matrixIndex[i]==0) std::cout << "\\\\x00";
        else if(i==0) std::cout << "\\\\xff";
        else if(this->matrixIndex[i]=='\n') std::cout << "\\n";
        else std::cout << this->matrixIndex[i];
    }
    std::cout << 
    "\",\n"
    "   \"edgemap\": {\n";
 
    for(int i=0;i<this->matrixSize;i++){
        if(this->matrixIndex[i]=='"') std::cout << "      \"\\\"\": [";
        else if(this->matrixIndex[i]=='\\') std::cout << "      \"\\\\\": [";
        else if(this->matrixIndex[i]==0) std::cout << "      \"\\\\x00\": [";
        else if(this->matrixIndex[i]<0) std::cout << "      \"\\\\xff\": [";
        else std::cout << "      \"" << this->matrixIndex[i] << "\": [";
        for(int j=0;j<this->matrixSize;j++){
            if(this->edgeMatrix[i][j]=='"') std::cout << "\"\\\"\"";
            else if(this->edgeMatrix[i][j]=='\\') std::cout << "\"\\\\\"";
            else if(this->edgeMatrix[i][j]==0) std::cout << "\"\\\\x00\"";
            else if(this->edgeMatrix[i][j]<0) std::cout << "\"\\\\xff\"";
            else if(this->matrixIndex[i]=='\n') std::cout << "\"\\n\"";
            else std::cout << "\"" << this->edgeMatrix[i][j] << "\"";
            if(j!=this->matrixSize-1) std::cout << ", ";
        }
        std::cout << "],\n";
    }
    std::cout << "},\n";
 
    std::cout << "\"   weightmap\": {\n";
    for(int i=0;i<this->matrixSize;i++){
        if(this->matrixIndex[i]=='"') std::cout << "      \"\\\"\": [";
        else if(this->matrixIndex[i]=='\\') std::cout << "      \"\\\\\": [";
        else if(this->matrixIndex[i]==0) std::cout << "      \"\\\\x00\": [";
        else if(this->matrixIndex[i]<0) std::cout << "      \"\\\\xff\": [";
        else std::cout << "      \"" << this->matrixIndex[i] << "\": [";
 
        for(int j=0;j<this->matrixSize;j++){
            std::cout << this->valueMatrix[i][j];
            if(j!=this->matrixSize-1) std::cout << ", ";
        }
        std::cout << "],\n";
    }
    std::cout << "  }\n}\n";
}

References Markov::API::ModelMatrix::edgeMatrix, Markov::API::ModelMatrix::matrixIndex, Markov::API::ModelMatrix::matrixSize, and Markov::API::ModelMatrix::valueMatrix.

Referenced by Markov::Markopy::CUDA::BOOST_PYTHON_MODULE(), and Markov::Markopy::BOOST_PYTHON_MODULE().

Here is the caller graph for this function:

DumpJSON() [3/3]

void Markov::API::ModelMatrix::DumpJSON ( )

inherited

Debug function to dump the model to a JSON file.

Might not work 100%. Not meant for production use.

Definition at line 101 of file modelMatrix.cpp.

                                   {
 
    std::cout << "{\n   \"index\": \"";
    for(int i=0;i<this->matrixSize;i++){
        if(this->matrixIndex[i]=='"') std::cout << "\\\"";
        else if(this->matrixIndex[i]=='\\') std::cout << "\\\\";
        else if(this->matrixIndex[i]==0) std::cout << "\\\\x00";
        else if(i==0) std::cout << "\\\\xff";
        else if(this->matrixIndex[i]=='\n') std::cout << "\\n";
        else std::cout << this->matrixIndex[i];
    }
    std::cout << 
    "\",\n"
    "   \"edgemap\": {\n";
 
    for(int i=0;i<this->matrixSize;i++){
        if(this->matrixIndex[i]=='"') std::cout << "      \"\\\"\": [";
        else if(this->matrixIndex[i]=='\\') std::cout << "      \"\\\\\": [";
        else if(this->matrixIndex[i]==0) std::cout << "      \"\\\\x00\": [";
        else if(this->matrixIndex[i]<0) std::cout << "      \"\\\\xff\": [";
        else std::cout << "      \"" << this->matrixIndex[i] << "\": [";
        for(int j=0;j<this->matrixSize;j++){
            if(this->edgeMatrix[i][j]=='"') std::cout << "\"\\\"\"";
            else if(this->edgeMatrix[i][j]=='\\') std::cout << "\"\\\\\"";
            else if(this->edgeMatrix[i][j]==0) std::cout << "\"\\\\x00\"";
            else if(this->edgeMatrix[i][j]<0) std::cout << "\"\\\\xff\"";
            else if(this->matrixIndex[i]=='\n') std::cout << "\"\\n\"";
            else std::cout << "\"" << this->edgeMatrix[i][j] << "\"";
            if(j!=this->matrixSize-1) std::cout << ", ";
        }
        std::cout << "],\n";
    }
    std::cout << "},\n";
 
    std::cout << "\"   weightmap\": {\n";
    for(int i=0;i<this->matrixSize;i++){
        if(this->matrixIndex[i]=='"') std::cout << "      \"\\\"\": [";
        else if(this->matrixIndex[i]=='\\') std::cout << "      \"\\\\\": [";
        else if(this->matrixIndex[i]==0) std::cout << "      \"\\\\x00\": [";
        else if(this->matrixIndex[i]<0) std::cout << "      \"\\\\xff\": [";
        else std::cout << "      \"" << this->matrixIndex[i] << "\": [";
 
        for(int j=0;j<this->matrixSize;j++){
            std::cout << this->valueMatrix[i][j];
            if(j!=this->matrixSize-1) std::cout << ", ";
        }
        std::cout << "],\n";
    }
    std::cout << "  }\n}\n";
}

References Markov::API::ModelMatrix::edgeMatrix, Markov::API::ModelMatrix::matrixIndex, Markov::API::ModelMatrix::matrixSize, and Markov::API::ModelMatrix::valueMatrix.

Referenced by Markov::Markopy::CUDA::BOOST_PYTHON_MODULE(), and Markov::Markopy::BOOST_PYTHON_MODULE().

Here is the caller graph for this function:

Edges() [1/4]

std::vector<Edge<char >*>* Markov::Model< char >::Edges ( )

inlineinherited

Return a vector of all the edges in the model.

Returns

vector of edges

Definition at line 176 of file model.h.

{ return &edges;}

Edges() [2/4]

std::vector<Edge<char >*>* Markov::Model< char >::Edges ( )

inlineinherited

Return a vector of all the edges in the model.

Returns

vector of edges

Definition at line 176 of file model.h.

{ return &edges;}

Edges() [3/4]

std::vector<Edge<char >*>* Markov::Model< char >::Edges ( )

inlineinherited

Return a vector of all the edges in the model.

Returns

vector of edges

Definition at line 176 of file model.h.

{ return &edges;}

Edges() [4/4]

std::vector<Edge<char >*>* Markov::Model< char >::Edges ( )

inlineinherited

Return a vector of all the edges in the model.

Returns

vector of edges

Definition at line 176 of file model.h.

{ return &edges;}

evaluate()

def Python.Markopy.MarkopyCLI.evaluate (   self, str  filename  )

inherited

Definition at line 163 of file markopy.py.

    def evaluate(self,filename : str):
        if(not self.args.evaluate_type):
            if(filename.endswith(".mdl")):
                ModelEvaluator(filename).evaluate()
            else:
                CorpusEvaluator(filename).evaluate()
        else:
            if(self.args.evaluate_type == "model"):
                ModelEvaluator(filename).evaluate()
            else:
                CorpusEvaluator(filename).evaluate()
    

Referenced by Python.Markopy.MarkopyCLI.parse().

Here is the caller graph for this function:

Export() [1/9]

bool Markov::Model< char >::Export ( const char *  filename )

inherited

Open a file to export with filename, and call bool Model::Export with std::ofstream.

Returns

True if successful, False for incomplete models or corrupt file formats

Example Use: Export file to filename

Markov::Model<char> model;
model.Export("test.mdl");

Definition at line 166 of file model.h.

                                                              {
    std::ofstream exportfile;
    exportfile.open(filename);
    return this->Export(&exportfile);
}

Export() [2/9]

bool Markov::Model< char >::Export ( const char *  filename )

inherited

Open a file to export with filename, and call bool Model::Export with std::ofstream.

Returns

True if successful, False for incomplete models or corrupt file formats

Example Use: Export file to filename

Markov::Model<char> model;
model.Export("test.mdl");

Definition at line 166 of file model.h.

                                                              {
    std::ofstream exportfile;
    exportfile.open(filename);
    return this->Export(&exportfile);
}

Export() [3/9]

bool Markov::Model< char >::Export ( const char *  filename )

inherited

Open a file to export with filename, and call bool Model::Export with std::ofstream.

Returns

True if successful, False for incomplete models or corrupt file formats

Example Use: Export file to filename

Markov::Model<char> model;
model.Export("test.mdl");

Definition at line 166 of file model.h.

                                                              {
    std::ofstream exportfile;
    exportfile.open(filename);
    return this->Export(&exportfile);
}

Export() [4/9]

bool Markov::Model< char >::Export ( const char *  filename )

inherited

Open a file to export with filename, and call bool Model::Export with std::ofstream.

Returns

True if successful, False for incomplete models or corrupt file formats

Example Use: Export file to filename

Markov::Model<char> model;
model.Export("test.mdl");

Definition at line 166 of file model.h.

                                                              {
    std::ofstream exportfile;
    exportfile.open(filename);
    return this->Export(&exportfile);
}

export() [1/6]

def Python.Markopy.BaseCLI.export (   self, str  filename  )

inherited

Export model to a file.

Parameters

filename

filename to export to

Definition at line 138 of file base.py.

    def export(self, filename : str):
        """! 
        @brief Export model to a file
        @param filename filename to export to
        """
        self.model.Export(filename)
 

References Python.CudaMarkopy.CudaModelMatrixCLI.model, Python.Markopy.BaseCLI.model, Python.Markopy.ModelMatrixCLI.model, Python.Markopy.MarkovPasswordsCLI.model, and Markov::GUI::MarkovPasswordsGUI.model().

Referenced by Python.Markopy.BaseCLI.train().

Here is the call graph for this function:

Here is the caller graph for this function:

export() [2/6]

def Python.Markopy.BaseCLI.export (   self, str  filename  )

inherited

Export model to a file.

Parameters

filename

filename to export to

Definition at line 138 of file base.py.

    def export(self, filename : str):
        """! 
        @brief Export model to a file
        @param filename filename to export to
        """
        self.model.Export(filename)
 

References Python.CudaMarkopy.CudaModelMatrixCLI.model, Python.Markopy.BaseCLI.model, Python.Markopy.ModelMatrixCLI.model, Python.Markopy.MarkovPasswordsCLI.model, and Markov::GUI::MarkovPasswordsGUI.model().

Referenced by Python.Markopy.BaseCLI.train().

Here is the call graph for this function:

Here is the caller graph for this function:

export() [3/6]

def Python.Markopy.BaseCLI.export (   self, str  filename  )

inherited

Export model to a file.

Parameters

filename

filename to export to

Definition at line 138 of file base.py.

    def export(self, filename : str):
        """! 
        @brief Export model to a file
        @param filename filename to export to
        """
        self.model.Export(filename)
 

References Python.CudaMarkopy.CudaModelMatrixCLI.model, Python.Markopy.BaseCLI.model, Python.Markopy.ModelMatrixCLI.model, Python.Markopy.MarkovPasswordsCLI.model, and Markov::GUI::MarkovPasswordsGUI.model().

Referenced by Python.Markopy.BaseCLI.train().

Here is the call graph for this function:

Here is the caller graph for this function:

export() [4/6]

def Python.Markopy.BaseCLI.export (   self, str  filename  )

inherited

Export model to a file.

Parameters

filename

filename to export to

Definition at line 138 of file base.py.

    def export(self, filename : str):
        """! 
        @brief Export model to a file
        @param filename filename to export to
        """
        self.model.Export(filename)
 

References Python.CudaMarkopy.CudaModelMatrixCLI.model, Python.Markopy.BaseCLI.model, Python.Markopy.ModelMatrixCLI.model, Python.Markopy.MarkovPasswordsCLI.model, and Markov::GUI::MarkovPasswordsGUI.model().

Referenced by Python.Markopy.BaseCLI.train().

Here is the call graph for this function:

Here is the caller graph for this function:

export() [5/6]

def Python.Markopy.BaseCLI.export (   self, str  filename  )

inherited

Export model to a file.

Parameters

filename

filename to export to

Definition at line 138 of file base.py.

    def export(self, filename : str):
        """! 
        @brief Export model to a file
        @param filename filename to export to
        """
        self.model.Export(filename)
 

References Python.CudaMarkopy.CudaModelMatrixCLI.model, Python.Markopy.BaseCLI.model, Python.Markopy.ModelMatrixCLI.model, Python.Markopy.MarkovPasswordsCLI.model, and Markov::GUI::MarkovPasswordsGUI.model().

Referenced by Python.Markopy.BaseCLI.train().

Here is the call graph for this function:

Here is the caller graph for this function:

export() [6/6]

def Python.Markopy.BaseCLI.export (   self, str  filename  )

inherited

Export model to a file.

Parameters

filename

filename to export to

Definition at line 138 of file base.py.

    def export(self, filename : str):
        """! 
        @brief Export model to a file
        @param filename filename to export to
        """
        self.model.Export(filename)
 

References Python.CudaMarkopy.CudaModelMatrixCLI.model, Python.Markopy.BaseCLI.model, Python.Markopy.ModelMatrixCLI.model, Python.Markopy.MarkovPasswordsCLI.model, and Markov::GUI::MarkovPasswordsGUI.model().

Referenced by Python.Markopy.BaseCLI.train().

Here is the call graph for this function:

Here is the caller graph for this function:

Export() [5/9]

bool Markov::Model< char >::Export ( std::ofstream *  f )

inherited

Export a file of the model.

File contains a list of edges. Format is: Left_repr;EdgeWeight;right_repr. For more information on the format, check out the project wiki or github readme.

Iterate over this vertices, and their edges, and write them to file.

Returns

True if successful, False for incomplete models.

Example Use: Export file to ofstream

Markov::Model<char> model;
std::ofstream file("test.mdl");
model.Export(&file);

Definition at line 155 of file model.h.

                                                        {
    Markov::Edge<NodeStorageType>* e;
    for (std::vector<int>::size_type i = 0; i != this->edges.size(); i++) {
        e = this->edges[i];
        //std::cout << e->LeftNode()->NodeValue() << "," << e->EdgeWeight() << "," << e->RightNode()->NodeValue() << "\n";
        *f << e->LeftNode()->NodeValue() << "," << e->EdgeWeight() << "," << e->RightNode()->NodeValue() << "\n";
    }
 
    return true;
}

Export() [6/9]

bool Markov::Model< char >::Export ( std::ofstream *  f )

inherited

Export a file of the model.

File contains a list of edges. Format is: Left_repr;EdgeWeight;right_repr. For more information on the format, check out the project wiki or github readme.

Iterate over this vertices, and their edges, and write them to file.

Returns

True if successful, False for incomplete models.

Example Use: Export file to ofstream

Markov::Model<char> model;
std::ofstream file("test.mdl");
model.Export(&file);

Definition at line 155 of file model.h.

                                                        {
    Markov::Edge<NodeStorageType>* e;
    for (std::vector<int>::size_type i = 0; i != this->edges.size(); i++) {
        e = this->edges[i];
        //std::cout << e->LeftNode()->NodeValue() << "," << e->EdgeWeight() << "," << e->RightNode()->NodeValue() << "\n";
        *f << e->LeftNode()->NodeValue() << "," << e->EdgeWeight() << "," << e->RightNode()->NodeValue() << "\n";
    }
 
    return true;
}

Export() [7/9]

bool Markov::Model< char >::Export ( std::ofstream *  f )

inherited

Export a file of the model.

File contains a list of edges. Format is: Left_repr;EdgeWeight;right_repr. For more information on the format, check out the project wiki or github readme.

Iterate over this vertices, and their edges, and write them to file.

Returns

True if successful, False for incomplete models.

Example Use: Export file to ofstream

Markov::Model<char> model;
std::ofstream file("test.mdl");
model.Export(&file);

Definition at line 155 of file model.h.

                                                        {
    Markov::Edge<NodeStorageType>* e;
    for (std::vector<int>::size_type i = 0; i != this->edges.size(); i++) {
        e = this->edges[i];
        //std::cout << e->LeftNode()->NodeValue() << "," << e->EdgeWeight() << "," << e->RightNode()->NodeValue() << "\n";
        *f << e->LeftNode()->NodeValue() << "," << e->EdgeWeight() << "," << e->RightNode()->NodeValue() << "\n";
    }
 
    return true;
}

Export() [8/9]

bool Markov::Model< char >::Export ( std::ofstream *  f )

inherited

Export a file of the model.

File contains a list of edges. Format is: Left_repr;EdgeWeight;right_repr. For more information on the format, check out the project wiki or github readme.

Iterate over this vertices, and their edges, and write them to file.

Returns

True if successful, False for incomplete models.

Example Use: Export file to ofstream

Markov::Model<char> model;
std::ofstream file("test.mdl");
model.Export(&file);

Definition at line 155 of file model.h.

                                                        {
    Markov::Edge<NodeStorageType>* e;
    for (std::vector<int>::size_type i = 0; i != this->edges.size(); i++) {
        e = this->edges[i];
        //std::cout << e->LeftNode()->NodeValue() << "," << e->EdgeWeight() << "," << e->RightNode()->NodeValue() << "\n";
        *f << e->LeftNode()->NodeValue() << "," << e->EdgeWeight() << "," << e->RightNode()->NodeValue() << "\n";
    }
 
    return true;
}

Export() [9/9]

def Python.Markopy.MarkovModel.Export ( str  filename )

inherited

Definition at line 26 of file mm.py.

    def Export(filename : str):
        pass
 

FastRandomWalk() [1/9]

def Python.Markopy.ModelMatrix.FastRandomWalk ( int  count, str  wordlist, int  minlen, int  maxlen  )

inherited

Definition at line 48 of file mm.py.

    def FastRandomWalk(count : int, wordlist : str, minlen : int, maxlen : int):
        pass

Referenced by Python.Markopy.ModelMatrixCLI._generate().

Here is the caller graph for this function:

FastRandomWalk() [2/9]

def Python.Markopy.ModelMatrix.FastRandomWalk ( int  count, str  wordlist, int  minlen, int  maxlen  )

inherited

Definition at line 48 of file mm.py.

    def FastRandomWalk(count : int, wordlist : str, minlen : int, maxlen : int):
        pass

Referenced by Python.Markopy.ModelMatrixCLI._generate().

Here is the caller graph for this function:

FastRandomWalk() [3/9]

__host__ void Markov::API::CUDA::CUDAModelMatrix::FastRandomWalk ( unsigned long int  n, const char *  wordlistFileName, int  minLen, int  maxLen, bool  bFileIO, bool  bInfinite  )

inherited

Random walk on the Matrix-reduced Markov::Model.

TODO

Parameters

n	- Number of passwords to generate.
wordlistFileName	- Filename to write to
minLen	- Minimum password length to generate
maxLen	- Maximum password length to generate
threads	- number of OS threads to spawn
bFileIO	- If false, filename will be ignored and will output to stdout.

Markov::API::ModelMatrix mp;
mp.Import("models/finished.mdl");
mp.FastRandomWalk(50000000,"./wordlist.txt",6,12,25, true);

Definition at line 58 of file cudaModelMatrix.cu.

                                                                                                                                                                     {
        cudaDeviceProp prop;
        int device=0;
        cudaGetDeviceProperties(&prop, device);
        cudaChooseDevice(&device, &prop);
        //std::cout << "Flattening matrix." << std::endl;
        this->FlattenMatrix();
        //std::cout << "Migrating matrix." << std::endl;
        this->MigrateMatrix();
        //std::cout << "Migrated matrix." << std::endl;
        std::ofstream wordlist; 
        if(bFileIO)
            wordlist.open(wordlistFileName);
 
 
        cudaBlocks = 1024;
        cudaThreads = 256;
        iterationsPerKernelThread = 100;
        alternatingKernels = 2;
        totalOutputPerKernel = (long int)cudaBlocks*(long int)cudaThreads*iterationsPerKernelThread;
        totalOutputPerSync= totalOutputPerKernel*alternatingKernels;
        numberOfPartitions = n/totalOutputPerSync;
        cudaGridSize = cudaBlocks*cudaThreads;
        cudaMemPerGrid = (maxLen+2)*iterationsPerKernelThread;
        cudaPerKernelAllocationSize = cudaGridSize*cudaMemPerGrid;
        this->prepKernelMemoryChannel(alternatingKernels);
        
        unsigned long int leftover = n - (totalOutputPerSync*numberOfPartitions);
 
        if(bInfinite && !numberOfPartitions) numberOfPartitions=5;
        std::cerr << cudaPerKernelAllocationSize << "\n";
 
        if(n%totalOutputPerSync) std::cerr << "For optimization, request outputs muliples of "<< totalOutputPerSync << ".\n";
 
        //start kernelID 1
        this->LaunchAsyncKernel(1, minLen, maxLen);
 
        for(int i=1;i<numberOfPartitions;i++){
            if(bInfinite) i=0;
 
            //wait kernelID1 to finish, and start kernelID 0
            cudaStreamSynchronize(this->cudastreams[1]);
            this->LaunchAsyncKernel(0, minLen, maxLen);
 
            //start memcpy from kernel 1 (block until done)
            this->GatherAsyncKernelOutput(1, bFileIO, wordlist);
            
            //wait kernelID 0 to finish, then start kernelID1
            cudaStreamSynchronize(this->cudastreams[0]);
            this->LaunchAsyncKernel(1, minLen, maxLen);
 
            //start memcpy from kernel 0 (block until done)
            this->GatherAsyncKernelOutput(0, bFileIO, wordlist);
            
        }
 
        //wait kernelID1 to finish, and start kernelID 0
        cudaStreamSynchronize(this->cudastreams[1]);
        this->LaunchAsyncKernel(0, minLen, maxLen);
        this->GatherAsyncKernelOutput(1, bFileIO, wordlist);
        cudaStreamSynchronize(this->cudastreams[0]);
        this->GatherAsyncKernelOutput(0, bFileIO, wordlist);
 
        
        if(!leftover) return;
        alternatingKernels=1;
        std::cerr << "Remaining line count (" << leftover << ") is lower than partition. Adjusting CUDA workload..\n";
        this->iterationsPerKernelThread = leftover/cudaGridSize;
        this->LaunchAsyncKernel(0, minLen, maxLen);
        cudaStreamSynchronize(this->cudastreams[0]);
        this->GatherAsyncKernelOutput(0, bFileIO, wordlist);
        
        leftover -= this->iterationsPerKernelThread*cudaGridSize;
        if(!leftover) return;
 
        std::cerr << "Remaining line count (" << leftover << ") is lower than minimum possible. Handing over to CPU generation.\n";
        this->iterationsPerKernelThread = leftover/cudaGridSize;
 
        leftover -= this->iterationsPerKernelThread;
 
        if(!leftover) return;
        std::cerr << "Remaining " << leftover << " lines are absolutely not worth printing.\n";
        Markov::API::ModelMatrix::ConstructMatrix();
        Markov::API::ModelMatrix::FastRandomWalk(leftover, &wordlist, minLen, maxLen, 1, bFileIO);
 
    }

References Markov::API::CUDA::CUDAModelMatrix::alternatingKernels, Markov::API::CUDA::CUDAModelMatrix::cudaBlocks, Markov::API::CUDA::CUDAModelMatrix::cudaGridSize, Markov::API::CUDA::CUDAModelMatrix::cudaMemPerGrid, Markov::API::CUDA::CUDAModelMatrix::cudaPerKernelAllocationSize, Markov::API::CUDA::CUDAModelMatrix::cudaThreads, Markov::API::CUDA::CUDAModelMatrix::iterationsPerKernelThread, Markov::API::CUDA::CUDAModelMatrix::numberOfPartitions, Markov::API::CUDA::CUDAModelMatrix::totalOutputPerKernel, and Markov::API::CUDA::CUDAModelMatrix::totalOutputPerSync.

Referenced by Python.CudaMarkopy.CudaModelMatrixCLI::_generate().

Here is the caller graph for this function:

FastRandomWalk() [4/9]

int Markov::API::ModelMatrix::FastRandomWalk ( unsigned long int  n, const char *  wordlistFileName, int  minLen = 6, int  maxLen = 12, int  threads = 20, bool  bFileIO = true  )

inherited

Random walk on the Matrix-reduced Markov::Model.

This has an O(N) Memory complexity. To limit the maximum usage, requests with n>50M are partitioned using Markov::API::ModelMatrix::FastRandomWalkPartition.

If n>50M, threads are going to be synced, files are going to be flushed, and buffers will be reallocated every 50M generations. This comes at a minor performance penalty.

While it has the same functionality, this operation reduces Markov::API::MarkovPasswords::Generate runtime by %96.5

This function has deprecated Markov::API::MarkovPasswords::Generate, and will eventually replace it.

Parameters

n	- Number of passwords to generate.
wordlistFileName	- Filename to write to
minLen	- Minimum password length to generate
maxLen	- Maximum password length to generate
threads	- number of OS threads to spawn
bFileIO	- If false, filename will be ignored and will output to stdout.

Markov::API::ModelMatrix mp;
mp.Import("models/finished.mdl");
mp.FastRandomWalk(50000000,"./wordlist.txt",6,12,25, true);

Definition at line 217 of file modelMatrix.cpp.

                                                                                                                                            {
    std::ofstream wordlist; 
    if(bFileIO)
        wordlist.open(wordlistFileName);
    this->FastRandomWalk(n, &wordlist, minLen, maxLen, threads, bFileIO);
    return 0;
}

References Markov::API::ModelMatrix::FastRandomWalk().

Referenced by Markov::Markopy::BOOST_PYTHON_MODULE().

Here is the call graph for this function:

Here is the caller graph for this function:

FastRandomWalk() [5/9]

int Markov::API::ModelMatrix::FastRandomWalk ( unsigned long int  n, const char *  wordlistFileName, int  minLen = 6, int  maxLen = 12, int  threads = 20, bool  bFileIO = true  )

inherited

Random walk on the Matrix-reduced Markov::Model.

This has an O(N) Memory complexity. To limit the maximum usage, requests with n>50M are partitioned using Markov::API::ModelMatrix::FastRandomWalkPartition.

If n>50M, threads are going to be synced, files are going to be flushed, and buffers will be reallocated every 50M generations. This comes at a minor performance penalty.

While it has the same functionality, this operation reduces Markov::API::MarkovPasswords::Generate runtime by %96.5

This function has deprecated Markov::API::MarkovPasswords::Generate, and will eventually replace it.

Parameters

n	- Number of passwords to generate.
wordlistFileName	- Filename to write to
minLen	- Minimum password length to generate
maxLen	- Maximum password length to generate
threads	- number of OS threads to spawn
bFileIO	- If false, filename will be ignored and will output to stdout.

Markov::API::ModelMatrix mp;
mp.Import("models/finished.mdl");
mp.FastRandomWalk(50000000,"./wordlist.txt",6,12,25, true);

Definition at line 217 of file modelMatrix.cpp.

                                                                                                                                            {
    std::ofstream wordlist; 
    if(bFileIO)
        wordlist.open(wordlistFileName);
    this->FastRandomWalk(n, &wordlist, minLen, maxLen, threads, bFileIO);
    return 0;
}

References Markov::API::ModelMatrix::FastRandomWalk().

Referenced by Markov::Markopy::BOOST_PYTHON_MODULE().

Here is the call graph for this function:

Here is the caller graph for this function:

FastRandomWalk() [6/9]

int Markov::API::ModelMatrix::FastRandomWalk ( unsigned long int  n, const char *  wordlistFileName, int  minLen = 6, int  maxLen = 12, int  threads = 20, bool  bFileIO = true  )

inherited

Random walk on the Matrix-reduced Markov::Model.

This has an O(N) Memory complexity. To limit the maximum usage, requests with n>50M are partitioned using Markov::API::ModelMatrix::FastRandomWalkPartition.

If n>50M, threads are going to be synced, files are going to be flushed, and buffers will be reallocated every 50M generations. This comes at a minor performance penalty.

While it has the same functionality, this operation reduces Markov::API::MarkovPasswords::Generate runtime by %96.5

This function has deprecated Markov::API::MarkovPasswords::Generate, and will eventually replace it.

Parameters

n	- Number of passwords to generate.
wordlistFileName	- Filename to write to
minLen	- Minimum password length to generate
maxLen	- Maximum password length to generate
threads	- number of OS threads to spawn
bFileIO	- If false, filename will be ignored and will output to stdout.

Markov::API::ModelMatrix mp;
mp.Import("models/finished.mdl");
mp.FastRandomWalk(50000000,"./wordlist.txt",6,12,25, true);

Definition at line 217 of file modelMatrix.cpp.

                                                                                                                                            {
    std::ofstream wordlist; 
    if(bFileIO)
        wordlist.open(wordlistFileName);
    this->FastRandomWalk(n, &wordlist, minLen, maxLen, threads, bFileIO);
    return 0;
}

References Markov::API::ModelMatrix::FastRandomWalk().

Referenced by Markov::Markopy::BOOST_PYTHON_MODULE().

Here is the call graph for this function:

Here is the caller graph for this function:

FastRandomWalk() [7/9]

int Markov::API::ModelMatrix::FastRandomWalk ( unsigned long int  n, std::ofstream *  wordlist, int  minLen = 6, int  maxLen = 12, int  threads = 20, bool  bFileIO = true  )

protectedinherited

Random walk on the Matrix-reduced Markov::Model.

This has an O(N) Memory complexity. To limit the maximum usage, requests with n>50M are partitioned using Markov::API::ModelMatrix::FastRandomWalkPartition.

If n>50M, threads are going to be synced, files are going to be flushed, and buffers will be reallocated every 50M generations. This comes at a minor performance penalty.

While it has the same functionality, this operation reduces Markov::API::MarkovPasswords::Generate runtime by %96.5

This function has deprecated Markov::API::MarkovPasswords::Generate, and will eventually replace it.

Parameters

n	- Number of passwords to generate.
wordlistFileName	- Filename to write to
minLen	- Minimum password length to generate
maxLen	- Maximum password length to generate
threads	- number of OS threads to spawn
bFileIO	- If false, filename will be ignored and will output to stdout.

Markov::API::ModelMatrix mp;
mp.Import("models/finished.mdl");
mp.FastRandomWalk(50000000,"./wordlist.txt",6,12,25, true);

Definition at line 204 of file modelMatrix.cpp.

                                                                                                                                     {
    
 
    std::mutex mlock;
    if(n<=50000000ull) this->FastRandomWalkPartition(&mlock, wordlist, n, minLen, maxLen, bFileIO, threads);
    else{
        int numberOfPartitions = n/50000000ull;
        for(int i=0;i<numberOfPartitions;i++)
            this->FastRandomWalkPartition(&mlock, wordlist, 50000000ull, minLen, maxLen, bFileIO, threads);
    }
    return 0;
}

References Markov::API::ModelMatrix::FastRandomWalkPartition().

Referenced by Markov::API::ModelMatrix::FastRandomWalk().

Here is the call graph for this function:

Here is the caller graph for this function:

FastRandomWalk() [8/9]

int Markov::API::ModelMatrix::FastRandomWalk ( unsigned long int  n, std::ofstream *  wordlist, int  minLen = 6, int  maxLen = 12, int  threads = 20, bool  bFileIO = true  )

protectedinherited

Random walk on the Matrix-reduced Markov::Model.

This has an O(N) Memory complexity. To limit the maximum usage, requests with n>50M are partitioned using Markov::API::ModelMatrix::FastRandomWalkPartition.

If n>50M, threads are going to be synced, files are going to be flushed, and buffers will be reallocated every 50M generations. This comes at a minor performance penalty.

While it has the same functionality, this operation reduces Markov::API::MarkovPasswords::Generate runtime by %96.5

This function has deprecated Markov::API::MarkovPasswords::Generate, and will eventually replace it.

Parameters

n	- Number of passwords to generate.
wordlistFileName	- Filename to write to
minLen	- Minimum password length to generate
maxLen	- Maximum password length to generate
threads	- number of OS threads to spawn
bFileIO	- If false, filename will be ignored and will output to stdout.

Markov::API::ModelMatrix mp;
mp.Import("models/finished.mdl");
mp.FastRandomWalk(50000000,"./wordlist.txt",6,12,25, true);

Definition at line 204 of file modelMatrix.cpp.

                                                                                                                                     {
    
 
    std::mutex mlock;
    if(n<=50000000ull) this->FastRandomWalkPartition(&mlock, wordlist, n, minLen, maxLen, bFileIO, threads);
    else{
        int numberOfPartitions = n/50000000ull;
        for(int i=0;i<numberOfPartitions;i++)
            this->FastRandomWalkPartition(&mlock, wordlist, 50000000ull, minLen, maxLen, bFileIO, threads);
    }
    return 0;
}

References Markov::API::ModelMatrix::FastRandomWalkPartition().

Referenced by Markov::API::ModelMatrix::FastRandomWalk().

Here is the call graph for this function:

Here is the caller graph for this function:

FastRandomWalk() [9/9]

int Markov::API::ModelMatrix::FastRandomWalk ( unsigned long int  n, std::ofstream *  wordlist, int  minLen = 6, int  maxLen = 12, int  threads = 20, bool  bFileIO = true  )

protectedinherited

Random walk on the Matrix-reduced Markov::Model.

This has an O(N) Memory complexity. To limit the maximum usage, requests with n>50M are partitioned using Markov::API::ModelMatrix::FastRandomWalkPartition.

If n>50M, threads are going to be synced, files are going to be flushed, and buffers will be reallocated every 50M generations. This comes at a minor performance penalty.

While it has the same functionality, this operation reduces Markov::API::MarkovPasswords::Generate runtime by %96.5

This function has deprecated Markov::API::MarkovPasswords::Generate, and will eventually replace it.

Parameters

n	- Number of passwords to generate.
wordlistFileName	- Filename to write to
minLen	- Minimum password length to generate
maxLen	- Maximum password length to generate
threads	- number of OS threads to spawn
bFileIO	- If false, filename will be ignored and will output to stdout.

Markov::API::ModelMatrix mp;
mp.Import("models/finished.mdl");
mp.FastRandomWalk(50000000,"./wordlist.txt",6,12,25, true);

Definition at line 204 of file modelMatrix.cpp.

                                                                                                                                     {
    
 
    std::mutex mlock;
    if(n<=50000000ull) this->FastRandomWalkPartition(&mlock, wordlist, n, minLen, maxLen, bFileIO, threads);
    else{
        int numberOfPartitions = n/50000000ull;
        for(int i=0;i<numberOfPartitions;i++)
            this->FastRandomWalkPartition(&mlock, wordlist, 50000000ull, minLen, maxLen, bFileIO, threads);
    }
    return 0;
}

References Markov::API::ModelMatrix::FastRandomWalkPartition().

Referenced by Markov::API::ModelMatrix::FastRandomWalk().

Here is the call graph for this function:

Here is the caller graph for this function:

FastRandomWalkPartition() [1/3]

void Markov::API::ModelMatrix::FastRandomWalkPartition ( std::mutex *  mlock, std::ofstream *  wordlist, unsigned long int  n, int  minLen, int  maxLen, bool  bFileIO, int  threads  )

protectedinherited

A single partition of FastRandomWalk event.

Since FastRandomWalk has to allocate its output buffer before operation starts and writes data in chunks, large n parameters would lead to huge memory allocations. Without Partitioning:

• 50M results 12 characters max -> 550 Mb Memory allocation
• 5B results 12 characters max -> 55 Gb Memory allocation
• 50B results 12 characters max -> 550GB Memory allocation

Instead, FastRandomWalk is partitioned per 50M generations to limit the top memory need.

Parameters

mlock	- mutex lock to distribute to child threads
wordlist	- Reference to the wordlist file to write to
n	- Number of passwords to generate.
wordlistFileName	- Filename to write to
minLen	- Minimum password length to generate
maxLen	- Maximum password length to generate
threads	- number of OS threads to spawn
bFileIO	- If false, filename will be ignored and will output to stdout.

Definition at line 225 of file modelMatrix.cpp.

                                                                                                                                                                {
    
    int iterationsPerThread = n/threads;
    int iterationsPerThreadCarryOver = n%threads;
 
    std::vector<std::thread*> threadsV;
    
    int id = 0;
    for(int i=0;i<threads;i++){
        threadsV.push_back(new std::thread(&Markov::API::ModelMatrix::FastRandomWalkThread, this, mlock, wordlist, iterationsPerThread, minLen, maxLen, id, bFileIO));
        id++;
    }
 
    threadsV.push_back(new std::thread(&Markov::API::ModelMatrix::FastRandomWalkThread, this, mlock, wordlist, iterationsPerThreadCarryOver, minLen, maxLen, id, bFileIO));
 
    for(int i=0;i<threads;i++){
        threadsV[i]->join();
    }
}

References Markov::API::ModelMatrix::FastRandomWalkThread().

Referenced by Markov::API::ModelMatrix::FastRandomWalk().

Here is the call graph for this function:

Here is the caller graph for this function:

FastRandomWalkPartition() [2/3]

void Markov::API::ModelMatrix::FastRandomWalkPartition ( std::mutex *  mlock, std::ofstream *  wordlist, unsigned long int  n, int  minLen, int  maxLen, bool  bFileIO, int  threads  )

protectedinherited

A single partition of FastRandomWalk event.

Since FastRandomWalk has to allocate its output buffer before operation starts and writes data in chunks, large n parameters would lead to huge memory allocations. Without Partitioning:

• 50M results 12 characters max -> 550 Mb Memory allocation
• 5B results 12 characters max -> 55 Gb Memory allocation
• 50B results 12 characters max -> 550GB Memory allocation

Instead, FastRandomWalk is partitioned per 50M generations to limit the top memory need.

Parameters

mlock	- mutex lock to distribute to child threads
wordlist	- Reference to the wordlist file to write to
n	- Number of passwords to generate.
wordlistFileName	- Filename to write to
minLen	- Minimum password length to generate
maxLen	- Maximum password length to generate
threads	- number of OS threads to spawn
bFileIO	- If false, filename will be ignored and will output to stdout.

Definition at line 225 of file modelMatrix.cpp.

                                                                                                                                                                {
    
    int iterationsPerThread = n/threads;
    int iterationsPerThreadCarryOver = n%threads;
 
    std::vector<std::thread*> threadsV;
    
    int id = 0;
    for(int i=0;i<threads;i++){
        threadsV.push_back(new std::thread(&Markov::API::ModelMatrix::FastRandomWalkThread, this, mlock, wordlist, iterationsPerThread, minLen, maxLen, id, bFileIO));
        id++;
    }
 
    threadsV.push_back(new std::thread(&Markov::API::ModelMatrix::FastRandomWalkThread, this, mlock, wordlist, iterationsPerThreadCarryOver, minLen, maxLen, id, bFileIO));
 
    for(int i=0;i<threads;i++){
        threadsV[i]->join();
    }
}

References Markov::API::ModelMatrix::FastRandomWalkThread().

Referenced by Markov::API::ModelMatrix::FastRandomWalk().

Here is the call graph for this function:

Here is the caller graph for this function:

FastRandomWalkPartition() [3/3]

void Markov::API::ModelMatrix::FastRandomWalkPartition ( std::mutex *  mlock, std::ofstream *  wordlist, unsigned long int  n, int  minLen, int  maxLen, bool  bFileIO, int  threads  )

protectedinherited

A single partition of FastRandomWalk event.

Since FastRandomWalk has to allocate its output buffer before operation starts and writes data in chunks, large n parameters would lead to huge memory allocations. Without Partitioning:

• 50M results 12 characters max -> 550 Mb Memory allocation
• 5B results 12 characters max -> 55 Gb Memory allocation
• 50B results 12 characters max -> 550GB Memory allocation

Instead, FastRandomWalk is partitioned per 50M generations to limit the top memory need.

Parameters

mlock	- mutex lock to distribute to child threads
wordlist	- Reference to the wordlist file to write to
n	- Number of passwords to generate.
wordlistFileName	- Filename to write to
minLen	- Minimum password length to generate
maxLen	- Maximum password length to generate
threads	- number of OS threads to spawn
bFileIO	- If false, filename will be ignored and will output to stdout.

Definition at line 225 of file modelMatrix.cpp.

                                                                                                                                                                {
    
    int iterationsPerThread = n/threads;
    int iterationsPerThreadCarryOver = n%threads;
 
    std::vector<std::thread*> threadsV;
    
    int id = 0;
    for(int i=0;i<threads;i++){
        threadsV.push_back(new std::thread(&Markov::API::ModelMatrix::FastRandomWalkThread, this, mlock, wordlist, iterationsPerThread, minLen, maxLen, id, bFileIO));
        id++;
    }
 
    threadsV.push_back(new std::thread(&Markov::API::ModelMatrix::FastRandomWalkThread, this, mlock, wordlist, iterationsPerThreadCarryOver, minLen, maxLen, id, bFileIO));
 
    for(int i=0;i<threads;i++){
        threadsV[i]->join();
    }
}

References Markov::API::ModelMatrix::FastRandomWalkThread().

Referenced by Markov::API::ModelMatrix::FastRandomWalk().

Here is the call graph for this function:

Here is the caller graph for this function:

FastRandomWalkThread() [1/3]

void Markov::API::ModelMatrix::FastRandomWalkThread ( std::mutex *  mlock, std::ofstream *  wordlist, unsigned long int  n, int  minLen, int  maxLen, int  id, bool  bFileIO  )

protectedinherited

A single thread of a single partition of FastRandomWalk.

A FastRandomWalkPartition will initiate as many of this function as requested.

This function contains the bulk of the generation algorithm.

Parameters

mlock	- mutex lock to distribute to child threads
wordlist	- Reference to the wordlist file to write to
n	- Number of passwords to generate.
wordlistFileName	- Filename to write to
minLen	- Minimum password length to generate
maxLen	- Maximum password length to generate
id	- DEPRECATED Thread id - No longer used
bFileIO	- If false, filename will be ignored and will output to stdout.

Definition at line 153 of file modelMatrix.cpp.

                                                                                                                                                        {
    if(n==0) return;
 
    Markov::Random::Marsaglia MarsagliaRandomEngine;
    char* e;
    char *res = new char[(maxLen+2)*n];
    int index = 0;
    char next;
    int len=0;
    long int selection;
    char cur;
    long int bufferctr = 0;
    for (int i = 0; i < n; i++) {
        cur=199;
        len=0;
        while (true) {
            e = strchr(this->matrixIndex, cur);
            index = e - this->matrixIndex;
            selection = MarsagliaRandomEngine.random() % this->totalEdgeWeights[index];
            for(int j=0;j<this->matrixSize;j++){
                selection -= this->valueMatrix[index][j];
                if (selection < 0){
                    next = this->edgeMatrix[index][j];
                    break;
                }
            }
 
            if (len >= maxLen)  break;
            else if ((next < 0) && (len < minLen)) continue;
            else if (next < 0) break;  
            cur = next;
            res[bufferctr + len++] = cur;
        }
        res[bufferctr + len++] = '\n';
        bufferctr+=len;
        
    }
    if(bFileIO){
        mlock->lock();
        *wordlist << res;
        mlock->unlock();
    }else{
        mlock->lock();
        std::cout << res;
        mlock->unlock();
    }
    delete res;
 
}

References Markov::API::ModelMatrix::edgeMatrix, Markov::API::ModelMatrix::matrixIndex, Markov::API::ModelMatrix::matrixSize, Markov::Random::Marsaglia::random(), Markov::API::ModelMatrix::totalEdgeWeights, and Markov::API::ModelMatrix::valueMatrix.

Referenced by Markov::API::ModelMatrix::FastRandomWalkPartition().

Here is the call graph for this function:

Here is the caller graph for this function:

FastRandomWalkThread() [2/3]

void Markov::API::ModelMatrix::FastRandomWalkThread ( std::mutex *  mlock, std::ofstream *  wordlist, unsigned long int  n, int  minLen, int  maxLen, int  id, bool  bFileIO  )

protectedinherited

A single thread of a single partition of FastRandomWalk.

A FastRandomWalkPartition will initiate as many of this function as requested.

This function contains the bulk of the generation algorithm.

Parameters

mlock	- mutex lock to distribute to child threads
wordlist	- Reference to the wordlist file to write to
n	- Number of passwords to generate.
wordlistFileName	- Filename to write to
minLen	- Minimum password length to generate
maxLen	- Maximum password length to generate
id	- DEPRECATED Thread id - No longer used
bFileIO	- If false, filename will be ignored and will output to stdout.

Definition at line 153 of file modelMatrix.cpp.

                                                                                                                                                        {
    if(n==0) return;
 
    Markov::Random::Marsaglia MarsagliaRandomEngine;
    char* e;
    char *res = new char[(maxLen+2)*n];
    int index = 0;
    char next;
    int len=0;
    long int selection;
    char cur;
    long int bufferctr = 0;
    for (int i = 0; i < n; i++) {
        cur=199;
        len=0;
        while (true) {
            e = strchr(this->matrixIndex, cur);
            index = e - this->matrixIndex;
            selection = MarsagliaRandomEngine.random() % this->totalEdgeWeights[index];
            for(int j=0;j<this->matrixSize;j++){
                selection -= this->valueMatrix[index][j];
                if (selection < 0){
                    next = this->edgeMatrix[index][j];
                    break;
                }
            }
 
            if (len >= maxLen)  break;
            else if ((next < 0) && (len < minLen)) continue;
            else if (next < 0) break;  
            cur = next;
            res[bufferctr + len++] = cur;
        }
        res[bufferctr + len++] = '\n';
        bufferctr+=len;
        
    }
    if(bFileIO){
        mlock->lock();
        *wordlist << res;
        mlock->unlock();
    }else{
        mlock->lock();
        std::cout << res;
        mlock->unlock();
    }
    delete res;
 
}

References Markov::API::ModelMatrix::edgeMatrix, Markov::API::ModelMatrix::matrixIndex, Markov::API::ModelMatrix::matrixSize, Markov::Random::Marsaglia::random(), Markov::API::ModelMatrix::totalEdgeWeights, and Markov::API::ModelMatrix::valueMatrix.

Referenced by Markov::API::ModelMatrix::FastRandomWalkPartition().

Here is the call graph for this function:

Here is the caller graph for this function:

FastRandomWalkThread() [3/3]

void Markov::API::ModelMatrix::FastRandomWalkThread ( std::mutex *  mlock, std::ofstream *  wordlist, unsigned long int  n, int  minLen, int  maxLen, int  id, bool  bFileIO  )

protectedinherited

A single thread of a single partition of FastRandomWalk.

A FastRandomWalkPartition will initiate as many of this function as requested.

This function contains the bulk of the generation algorithm.

Parameters

mlock	- mutex lock to distribute to child threads
wordlist	- Reference to the wordlist file to write to
n	- Number of passwords to generate.
wordlistFileName	- Filename to write to
minLen	- Minimum password length to generate
maxLen	- Maximum password length to generate
id	- DEPRECATED Thread id - No longer used
bFileIO	- If false, filename will be ignored and will output to stdout.

Definition at line 153 of file modelMatrix.cpp.

                                                                                                                                                        {
    if(n==0) return;
 
    Markov::Random::Marsaglia MarsagliaRandomEngine;
    char* e;
    char *res = new char[(maxLen+2)*n];
    int index = 0;
    char next;
    int len=0;
    long int selection;
    char cur;
    long int bufferctr = 0;
    for (int i = 0; i < n; i++) {
        cur=199;
        len=0;
        while (true) {
            e = strchr(this->matrixIndex, cur);
            index = e - this->matrixIndex;
            selection = MarsagliaRandomEngine.random() % this->totalEdgeWeights[index];
            for(int j=0;j<this->matrixSize;j++){
                selection -= this->valueMatrix[index][j];
                if (selection < 0){
                    next = this->edgeMatrix[index][j];
                    break;
                }
            }
 
            if (len >= maxLen)  break;
            else if ((next < 0) && (len < minLen)) continue;
            else if (next < 0) break;  
            cur = next;
            res[bufferctr + len++] = cur;
        }
        res[bufferctr + len++] = '\n';
        bufferctr+=len;
        
    }
    if(bFileIO){
        mlock->lock();
        *wordlist << res;
        mlock->unlock();
    }else{
        mlock->lock();
        std::cout << res;
        mlock->unlock();
    }
    delete res;
 
}

References Markov::API::ModelMatrix::edgeMatrix, Markov::API::ModelMatrix::matrixIndex, Markov::API::ModelMatrix::matrixSize, Markov::Random::Marsaglia::random(), Markov::API::ModelMatrix::totalEdgeWeights, and Markov::API::ModelMatrix::valueMatrix.

Referenced by Markov::API::ModelMatrix::FastRandomWalkPartition().

Here is the call graph for this function:

Here is the caller graph for this function:

FlattenMatrix()

__host__ void Markov::API::CUDA::CUDAModelMatrix::FlattenMatrix ( )

inherited

Flatten migrated matrix from 2d to 1d.

Definition at line 261 of file cudaModelMatrix.cu.

                                                             {
        this->flatEdgeMatrix = new char[this->matrixSize*this->matrixSize];
 
        this->flatValueMatrix = new long int[this->matrixSize*this->matrixSize];
        for(int i=0;i<this->matrixSize;i++){
            memcpy(&this->flatEdgeMatrix[i*this->matrixSize], this->edgeMatrix[i], this->matrixSize );
            memcpy(&this->flatValueMatrix[i*this->matrixSize], this->valueMatrix[i], this->matrixSize*sizeof(long int) );
        }
    }

References Markov::API::CUDA::CUDAModelMatrix::flatEdgeMatrix, Markov::API::CUDA::CUDAModelMatrix::flatValueMatrix, and Markov::API::ModelMatrix::matrixSize.

GatherAsyncKernelOutput()

__host__ void Markov::API::CUDA::CUDAModelMatrix::GatherAsyncKernelOutput ( int  kernelID, bool  bFileIO, std::ofstream &  wordlist  )

protectedinherited

Definition at line 180 of file cudaModelMatrix.cu.

                                                                                                                        {     
        cudaMemcpy(this->outputBuffer[kernelID],this->device_outputBuffer[kernelID],cudaPerKernelAllocationSize, cudaMemcpyDeviceToHost);
        //std::cerr << "Kernel" << kernelID << " output copied\n";
        if(bFileIO){
            for(long int j=0;j<cudaPerKernelAllocationSize;j+=cudaMemPerGrid){
                wordlist << &this->outputBuffer[kernelID][j];
            }
        }else{
            for(long int j=0;j<cudaPerKernelAllocationSize;j+=cudaMemPerGrid){
                std::cout << &this->outputBuffer[kernelID][j];
            }
        }
    }

References Markov::API::CUDA::CUDAModelMatrix::cudaMemPerGrid, Markov::API::CUDA::CUDAModelMatrix::cudaPerKernelAllocationSize, and Markov::API::CUDA::CUDAModelMatrix::outputBuffer.

Generate() [1/5]

def Python.Markopy.MarkovModel.Generate ( int  count, str  wordlist, int  minlen, int  maxlen, int  threads  )

inherited

Definition at line 34 of file mm.py.

    def Generate(count : int, wordlist : str, minlen : int, maxlen: int, threads : int):
        pass
 
 

Referenced by Python.Markopy.MarkovPasswordsCLI._generate().

Here is the caller graph for this function:

generate() [1/6]

def Python.Markopy.BaseCLI.generate (   self, str  wordlist, bool  bulk = False  )

inherited

Generate strings from the model.

Parameters

model	model instance
wordlist	wordlist filename
bulk	marks bulk operation with directories

Definition at line 145 of file base.py.

    def generate(self, wordlist : str, bulk : bool=False):
        """! 
            @brief Generate strings from the model
            @param model: model instance
            @param wordlist wordlist filename
            @param bulk marks bulk operation with directories
        """
        if not (wordlist or self.args.count):
            logging.pprint("Generation mode requires -w/--wordlist and -n/--count parameters. Exiting.")
            return False
    
        if(bulk and os.path.isfile(wordlist)):
            logging.pprint(f"{wordlist} exists and will be overwritten.", 1)
        self._generate(wordlist)
 

References Python.CudaMarkopy.CudaModelMatrixCLI._generate(), Python.Markopy.BaseCLI._generate(), Python.Markopy.ModelMatrixCLI._generate(), Python.Markopy.MarkovPasswordsCLI._generate(), Python.CudaMarkopy.CudaMarkopyCLI.args, Python.Markopy.BaseCLI.args, and Python.Markopy.MarkopyCLI.args.

Referenced by Python.Markopy.BaseCLI.process().

Here is the call graph for this function:

Here is the caller graph for this function:

generate() [2/6]

def Python.Markopy.BaseCLI.generate (   self, str  wordlist, bool  bulk = False  )

inherited

Generate strings from the model.

Parameters

model	model instance
wordlist	wordlist filename
bulk	marks bulk operation with directories

Definition at line 145 of file base.py.

    def generate(self, wordlist : str, bulk : bool=False):
        """! 
            @brief Generate strings from the model
            @param model: model instance
            @param wordlist wordlist filename
            @param bulk marks bulk operation with directories
        """
        if not (wordlist or self.args.count):
            logging.pprint("Generation mode requires -w/--wordlist and -n/--count parameters. Exiting.")
            return False
    
        if(bulk and os.path.isfile(wordlist)):
            logging.pprint(f"{wordlist} exists and will be overwritten.", 1)
        self._generate(wordlist)
 

References Python.CudaMarkopy.CudaModelMatrixCLI._generate(), Python.Markopy.BaseCLI._generate(), Python.Markopy.ModelMatrixCLI._generate(), Python.Markopy.MarkovPasswordsCLI._generate(), Python.CudaMarkopy.CudaMarkopyCLI.args, Python.Markopy.BaseCLI.args, and Python.Markopy.MarkopyCLI.args.

Referenced by Python.Markopy.BaseCLI.process().

Here is the call graph for this function:

Here is the caller graph for this function:

generate() [3/6]

def Python.Markopy.BaseCLI.generate (   self, str  wordlist, bool  bulk = False  )

inherited

Generate strings from the model.

Parameters

model	model instance
wordlist	wordlist filename
bulk	marks bulk operation with directories

Definition at line 145 of file base.py.

    def generate(self, wordlist : str, bulk : bool=False):
        """! 
            @brief Generate strings from the model
            @param model: model instance
            @param wordlist wordlist filename
            @param bulk marks bulk operation with directories
        """
        if not (wordlist or self.args.count):
            logging.pprint("Generation mode requires -w/--wordlist and -n/--count parameters. Exiting.")
            return False
    
        if(bulk and os.path.isfile(wordlist)):
            logging.pprint(f"{wordlist} exists and will be overwritten.", 1)
        self._generate(wordlist)
 

References Python.CudaMarkopy.CudaModelMatrixCLI._generate(), Python.Markopy.BaseCLI._generate(), Python.Markopy.ModelMatrixCLI._generate(), Python.Markopy.MarkovPasswordsCLI._generate(), Python.CudaMarkopy.CudaMarkopyCLI.args, Python.Markopy.BaseCLI.args, and Python.Markopy.MarkopyCLI.args.

Referenced by Python.Markopy.BaseCLI.process().

Here is the call graph for this function:

Here is the caller graph for this function:

generate() [4/6]

def Python.Markopy.BaseCLI.generate (   self, str  wordlist, bool  bulk = False  )

inherited

Generate strings from the model.

Parameters

model	model instance
wordlist	wordlist filename
bulk	marks bulk operation with directories

Definition at line 145 of file base.py.

    def generate(self, wordlist : str, bulk : bool=False):
        """! 
            @brief Generate strings from the model
            @param model: model instance
            @param wordlist wordlist filename
            @param bulk marks bulk operation with directories
        """
        if not (wordlist or self.args.count):
            logging.pprint("Generation mode requires -w/--wordlist and -n/--count parameters. Exiting.")
            return False
    
        if(bulk and os.path.isfile(wordlist)):
            logging.pprint(f"{wordlist} exists and will be overwritten.", 1)
        self._generate(wordlist)
 

References Python.CudaMarkopy.CudaModelMatrixCLI._generate(), Python.Markopy.BaseCLI._generate(), Python.Markopy.ModelMatrixCLI._generate(), Python.Markopy.MarkovPasswordsCLI._generate(), Python.CudaMarkopy.CudaMarkopyCLI.args, Python.Markopy.BaseCLI.args, and Python.Markopy.MarkopyCLI.args.

Referenced by Python.Markopy.BaseCLI.process().

Here is the call graph for this function:

Here is the caller graph for this function:

generate() [5/6]

def Python.Markopy.BaseCLI.generate (   self, str  wordlist, bool  bulk = False  )

inherited

Generate strings from the model.

Parameters

model	model instance
wordlist	wordlist filename
bulk	marks bulk operation with directories

Definition at line 145 of file base.py.

    def generate(self, wordlist : str, bulk : bool=False):
        """! 
            @brief Generate strings from the model
            @param model: model instance
            @param wordlist wordlist filename
            @param bulk marks bulk operation with directories
        """
        if not (wordlist or self.args.count):
            logging.pprint("Generation mode requires -w/--wordlist and -n/--count parameters. Exiting.")
            return False
    
        if(bulk and os.path.isfile(wordlist)):
            logging.pprint(f"{wordlist} exists and will be overwritten.", 1)
        self._generate(wordlist)
 

References Python.CudaMarkopy.CudaModelMatrixCLI._generate(), Python.Markopy.BaseCLI._generate(), Python.Markopy.ModelMatrixCLI._generate(), Python.Markopy.MarkovPasswordsCLI._generate(), Python.CudaMarkopy.CudaMarkopyCLI.args, Python.Markopy.BaseCLI.args, and Python.Markopy.MarkopyCLI.args.

Referenced by Python.Markopy.BaseCLI.process().

Here is the call graph for this function:

Here is the caller graph for this function:

generate() [6/6]

def Python.Markopy.BaseCLI.generate (   self, str  wordlist, bool  bulk = False  )

inherited

Generate strings from the model.

Parameters

model	model instance
wordlist	wordlist filename
bulk	marks bulk operation with directories

Definition at line 145 of file base.py.

    def generate(self, wordlist : str, bulk : bool=False):
        """! 
            @brief Generate strings from the model
            @param model: model instance
            @param wordlist wordlist filename
            @param bulk marks bulk operation with directories
        """
        if not (wordlist or self.args.count):
            logging.pprint("Generation mode requires -w/--wordlist and -n/--count parameters. Exiting.")
            return False
    
        if(bulk and os.path.isfile(wordlist)):
            logging.pprint(f"{wordlist} exists and will be overwritten.", 1)
        self._generate(wordlist)
 

References Python.CudaMarkopy.CudaModelMatrixCLI._generate(), Python.Markopy.BaseCLI._generate(), Python.Markopy.ModelMatrixCLI._generate(), Python.Markopy.MarkovPasswordsCLI._generate(), Python.CudaMarkopy.CudaMarkopyCLI.args, Python.Markopy.BaseCLI.args, and Python.Markopy.MarkopyCLI.args.

Referenced by Python.Markopy.BaseCLI.process().

Here is the call graph for this function:

Here is the caller graph for this function:

Generate() [2/5]

void Markov::API::MarkovPasswords::Generate ( unsigned long int  n, const char *  wordlistFileName, int  minLen = 6, int  maxLen = 12, int  threads = 20  )

inherited

Call Markov::Model::RandomWalk n times, and collect output.

Generate from model and write results to a file. a much more performance-optimized method. FastRandomWalk will reduce the runtime by %96.5 on average.

Deprecated:

See Markov::API::MatrixModel::FastRandomWalk for more information.

Parameters

n	- Number of passwords to generate.
wordlistFileName	- Filename to write to
minLen	- Minimum password length to generate
maxLen	- Maximum password length to generate
threads	- number of OS threads to spawn

Definition at line 118 of file markovPasswords.cpp.

                                                                                                                               {
    char* res;
    char print[100];
    std::ofstream wordlist; 
    wordlist.open(wordlistFileName);
    std::mutex mlock;
    int iterationsPerThread = n/threads;
    int iterationsCarryOver = n%threads;
    std::vector<std::thread*> threadsV;
    for(int i=0;i<threads;i++){
        threadsV.push_back(new std::thread(&Markov::API::MarkovPasswords::GenerateThread, this, &mlock, iterationsPerThread, &wordlist, minLen, maxLen));
    }
 
    for(int i=0;i<threads;i++){
        threadsV[i]->join();
        delete threadsV[i];
    }
 
    this->GenerateThread(&mlock, iterationsCarryOver, &wordlist, minLen, maxLen);
    
}

References Markov::API::MarkovPasswords::GenerateThread().

Referenced by Markov::Markopy::BOOST_PYTHON_MODULE(), and Markov::GUI::Generate::generation().

Here is the call graph for this function:

Here is the caller graph for this function:

Generate() [3/5]

void Markov::API::MarkovPasswords::Generate ( unsigned long int  n, const char *  wordlistFileName, int  minLen = 6, int  maxLen = 12, int  threads = 20  )

inherited

Call Markov::Model::RandomWalk n times, and collect output.

Generate from model and write results to a file. a much more performance-optimized method. FastRandomWalk will reduce the runtime by %96.5 on average.

Deprecated:

See Markov::API::MatrixModel::FastRandomWalk for more information.

Parameters

n	- Number of passwords to generate.
wordlistFileName	- Filename to write to
minLen	- Minimum password length to generate
maxLen	- Maximum password length to generate
threads	- number of OS threads to spawn

Definition at line 118 of file markovPasswords.cpp.

                                                                                                                               {
    char* res;
    char print[100];
    std::ofstream wordlist; 
    wordlist.open(wordlistFileName);
    std::mutex mlock;
    int iterationsPerThread = n/threads;
    int iterationsCarryOver = n%threads;
    std::vector<std::thread*> threadsV;
    for(int i=0;i<threads;i++){
        threadsV.push_back(new std::thread(&Markov::API::MarkovPasswords::GenerateThread, this, &mlock, iterationsPerThread, &wordlist, minLen, maxLen));
    }
 
    for(int i=0;i<threads;i++){
        threadsV[i]->join();
        delete threadsV[i];
    }
 
    this->GenerateThread(&mlock, iterationsCarryOver, &wordlist, minLen, maxLen);
    
}

References Markov::API::MarkovPasswords::GenerateThread().

Referenced by Markov::Markopy::BOOST_PYTHON_MODULE(), and Markov::GUI::Generate::generation().

Here is the call graph for this function:

Here is the caller graph for this function:

Generate() [4/5]

void Markov::API::MarkovPasswords::Generate ( unsigned long int  n, const char *  wordlistFileName, int  minLen = 6, int  maxLen = 12, int  threads = 20  )

inherited

Call Markov::Model::RandomWalk n times, and collect output.

Generate from model and write results to a file. a much more performance-optimized method. FastRandomWalk will reduce the runtime by %96.5 on average.

Deprecated:

See Markov::API::MatrixModel::FastRandomWalk for more information.

Parameters

n	- Number of passwords to generate.
wordlistFileName	- Filename to write to
minLen	- Minimum password length to generate
maxLen	- Maximum password length to generate
threads	- number of OS threads to spawn

Definition at line 118 of file markovPasswords.cpp.

                                                                                                                               {
    char* res;
    char print[100];
    std::ofstream wordlist; 
    wordlist.open(wordlistFileName);
    std::mutex mlock;
    int iterationsPerThread = n/threads;
    int iterationsCarryOver = n%threads;
    std::vector<std::thread*> threadsV;
    for(int i=0;i<threads;i++){
        threadsV.push_back(new std::thread(&Markov::API::MarkovPasswords::GenerateThread, this, &mlock, iterationsPerThread, &wordlist, minLen, maxLen));
    }
 
    for(int i=0;i<threads;i++){
        threadsV[i]->join();
        delete threadsV[i];
    }
 
    this->GenerateThread(&mlock, iterationsCarryOver, &wordlist, minLen, maxLen);
    
}

References Markov::API::MarkovPasswords::GenerateThread().

Referenced by Markov::Markopy::BOOST_PYTHON_MODULE(), and Markov::GUI::Generate::generation().

Here is the call graph for this function:

Here is the caller graph for this function:

Generate() [5/5]

void Markov::API::MarkovPasswords::Generate ( unsigned long int  n, const char *  wordlistFileName, int  minLen = 6, int  maxLen = 12, int  threads = 20  )

inherited

Call Markov::Model::RandomWalk n times, and collect output.

Generate from model and write results to a file. a much more performance-optimized method. FastRandomWalk will reduce the runtime by %96.5 on average.

Deprecated:

See Markov::API::MatrixModel::FastRandomWalk for more information.

Parameters

n	- Number of passwords to generate.
wordlistFileName	- Filename to write to
minLen	- Minimum password length to generate
maxLen	- Maximum password length to generate
threads	- number of OS threads to spawn

Definition at line 118 of file markovPasswords.cpp.

                                                                                                                               {
    char* res;
    char print[100];
    std::ofstream wordlist; 
    wordlist.open(wordlistFileName);
    std::mutex mlock;
    int iterationsPerThread = n/threads;
    int iterationsCarryOver = n%threads;
    std::vector<std::thread*> threadsV;
    for(int i=0;i<threads;i++){
        threadsV.push_back(new std::thread(&Markov::API::MarkovPasswords::GenerateThread, this, &mlock, iterationsPerThread, &wordlist, minLen, maxLen));
    }
 
    for(int i=0;i<threads;i++){
        threadsV[i]->join();
        delete threadsV[i];
    }
 
    this->GenerateThread(&mlock, iterationsCarryOver, &wordlist, minLen, maxLen);
    
}

References Markov::API::MarkovPasswords::GenerateThread().

Referenced by Markov::Markopy::BOOST_PYTHON_MODULE(), and Markov::GUI::Generate::generation().

Here is the call graph for this function:

Here is the caller graph for this function:

GenerateThread()

void Markov::API::MarkovPasswords::GenerateThread ( std::mutex *  outputLock, unsigned long int  n, std::ofstream *  wordlist, int  minLen, int  maxLen  )

privateinherited

A single thread invoked by the Generate function.

DEPRECATED: See Markov::API::MatrixModel::FastRandomWalkThread for more information. This has been replaced with a much more performance-optimized method. FastRandomWalk will reduce the runtime by %96.5 on average.

Parameters

outputLock	- shared mutex lock to lock during output operation. Prevents race condition on write.
n	number of lines to be generated by this thread
wordlist	wordlistfile
minLen	- Minimum password length to generate
maxLen	- Maximum password length to generate

Definition at line 140 of file markovPasswords.cpp.

                                                                                                                                       {
    char* res = new char[maxLen+5];
    if(n==0) return;
 
    Markov::Random::Marsaglia MarsagliaRandomEngine;
    for (int i = 0; i < n; i++) {
        this->RandomWalk(&MarsagliaRandomEngine, minLen, maxLen, res); 
        outputLock->lock();
        *wordlist << res << "\n";
        outputLock->unlock();
    }
}

References Markov::Model< NodeStorageType >::RandomWalk().

Referenced by Markov::API::MarkovPasswords::Generate().

Here is the call graph for this function:

Here is the caller graph for this function:

help()

def Python.CudaMarkopy.CudaMarkopyCLI.help

(

self

)

overload help function to print submodel helps

Reimplemented from Python.Markopy.MarkopyCLI.

Definition at line 61 of file cudamarkopy.py.

    def help(self):
        "! @brief overload help string"
        self.parser.print_help = self.stub
        self.args = self.parser.parse_known_args()[0]
        if(self.args.model_type!="_MMX"):
            if(self.args.model_type=="MP"):
                mp = MarkovPasswordsCLI()
                mp.add_arguments()
                mp.parser.print_help()
            elif(self.args.model_type=="MMX"):
                mp = ModelMatrixCLI()
                mp.add_arguments()
                mp.parser.print_help()
            elif(self.args.model_type == "CUDA"):
                mp = CudaModelMatrixCLI()
                mp.add_arguments()
                mp.parser.print_help()
        else:
            print(colored("Model Mode selection choices:", "green"))
            self.print_help()
            print(colored("Following are applicable for -mt MP mode:", "green"))
            mp = MarkovPasswordsCLI()
            mp.add_arguments()
            mp.parser.print_help()
            print(colored("Following are applicable for -mt MMX mode:", "green"))
            mp = ModelMatrixCLI()
            mp.add_arguments()
            mp.parser.print_help()
            print(colored("Following are applicable for -mt CUDA mode:", "green"))
            mp = CudaModelMatrixCLI()
            mp.add_arguments()
            mp.parser.print_help()
        exit()
 

References Python.Markopy.BaseCLI.parser, and Python.Markopy.MarkopyCLI.stub().

Referenced by Python.Markopy.MarkopyCLI.add_arguments().

Here is the call graph for this function:

Here is the caller graph for this function:

Import() [1/8]

void Markov::API::ModelMatrix::Import ( const char *  filename )

inherited

Open a file to import with filename, and call bool Model::Import with std::ifstream.

Returns

True if successful, False for incomplete models or corrupt file formats

Example Use: Import a file with filename

Markov::Model<char> model;
model.Import("test.mdl");

Construct the matrix when done.

Definition at line 19 of file modelMatrix.cpp.

                                                     {
    this->DeallocateMatrix();
    this->Markov::API::MarkovPasswords::Import(filename);
    this->ConstructMatrix();
}

References Markov::API::ModelMatrix::ConstructMatrix(), Markov::API::ModelMatrix::DeallocateMatrix(), and Markov::Model< NodeStorageType >::Import().

Referenced by Markov::Markopy::CUDA::BOOST_PYTHON_MODULE(), Markov::Markopy::BOOST_PYTHON_MODULE(), and main().

Here is the call graph for this function:

Here is the caller graph for this function:

Import() [2/8]

void Markov::API::ModelMatrix::Import ( const char *  filename )

inherited

Open a file to import with filename, and call bool Model::Import with std::ifstream.

Returns

True if successful, False for incomplete models or corrupt file formats

Example Use: Import a file with filename

Markov::Model<char> model;
model.Import("test.mdl");

Construct the matrix when done.

Definition at line 19 of file modelMatrix.cpp.

                                                     {
    this->DeallocateMatrix();
    this->Markov::API::MarkovPasswords::Import(filename);
    this->ConstructMatrix();
}

References Markov::API::ModelMatrix::ConstructMatrix(), Markov::API::ModelMatrix::DeallocateMatrix(), and Markov::Model< NodeStorageType >::Import().

Referenced by Markov::Markopy::CUDA::BOOST_PYTHON_MODULE(), Markov::Markopy::BOOST_PYTHON_MODULE(), and main().

Here is the call graph for this function:

Here is the caller graph for this function:

Import() [3/8]

void Markov::API::ModelMatrix::Import ( const char *  filename )

inherited

Open a file to import with filename, and call bool Model::Import with std::ifstream.

Returns

True if successful, False for incomplete models or corrupt file formats

Example Use: Import a file with filename

Markov::Model<char> model;
model.Import("test.mdl");

Construct the matrix when done.

Definition at line 19 of file modelMatrix.cpp.

                                                     {
    this->DeallocateMatrix();
    this->Markov::API::MarkovPasswords::Import(filename);
    this->ConstructMatrix();
}

References Markov::API::ModelMatrix::ConstructMatrix(), Markov::API::ModelMatrix::DeallocateMatrix(), and Markov::Model< NodeStorageType >::Import().

Referenced by Markov::Markopy::CUDA::BOOST_PYTHON_MODULE(), Markov::Markopy::BOOST_PYTHON_MODULE(), and main().

Here is the call graph for this function:

Here is the caller graph for this function:

Import() [4/8]

bool Markov::Model< char >::Import ( std::ifstream *  f )

inherited

Import a file to construct the model.

File contains a list of edges. For more info on the file format, check out the wiki and github readme pages. Format is: Left_repr;EdgeWeight;right_repr

Iterate over this list, and construct nodes and edges accordingly.

Returns

True if successful, False for incomplete models or corrupt file formats

Example Use: Import a file from ifstream

Markov::Model<char> model;
std::ifstream file("test.mdl");
model.Import(&file);

Definition at line 126 of file model.h.

                                                        {
    std::string cell;
 
    char src;
    char target;
    long int oc;
 
    while (std::getline(*f, cell)) {
        //std::cout << "cell: " << cell << std::endl;
        src = cell[0];
        target = cell[cell.length() - 1];
        char* j;
        oc = std::strtol(cell.substr(2, cell.length() - 2).c_str(),&j,10);
        //std::cout << oc << "\n";
        Markov::Node<NodeStorageType>* srcN;
        Markov::Node<NodeStorageType>* targetN;
        Markov::Edge<NodeStorageType>* e;
        if (this->nodes.find(src) == this->nodes.end()) {
            srcN = new Markov::Node<NodeStorageType>(src);
            this->nodes.insert(std::pair<char, Markov::Node<NodeStorageType>*>(src, srcN));
            //std::cout << "Creating new node at start.\n";
        }
        else {
            srcN = this->nodes.find(src)->second;
        }
 
        if (this->nodes.find(target) == this->nodes.end()) {
            targetN = new Markov::Node<NodeStorageType>(target);
            this->nodes.insert(std::pair<char, Markov::Node<NodeStorageType>*>(target, targetN));
            //std::cout << "Creating new node at end.\n";
        }
        else {
            targetN = this->nodes.find(target)->second;
        }
        e = srcN->Link(targetN);
        e->AdjustEdge(oc);
        this->edges.push_back(e);
 
        //std::cout << int(srcN->NodeValue()) << " --" << e->EdgeWeight() << "--> " << int(targetN->NodeValue()) << "\n";
 
 
    }
 
    this->OptimizeEdgeOrder();
 
    return true;
}

Import() [5/8]

bool Markov::Model< char >::Import ( std::ifstream *  f )

inherited

Import a file to construct the model.

File contains a list of edges. For more info on the file format, check out the wiki and github readme pages. Format is: Left_repr;EdgeWeight;right_repr

Iterate over this list, and construct nodes and edges accordingly.

Returns

True if successful, False for incomplete models or corrupt file formats

Example Use: Import a file from ifstream

Markov::Model<char> model;
std::ifstream file("test.mdl");
model.Import(&file);

Definition at line 126 of file model.h.

                                                        {
    std::string cell;
 
    char src;
    char target;
    long int oc;
 
    while (std::getline(*f, cell)) {
        //std::cout << "cell: " << cell << std::endl;
        src = cell[0];
        target = cell[cell.length() - 1];
        char* j;
        oc = std::strtol(cell.substr(2, cell.length() - 2).c_str(),&j,10);
        //std::cout << oc << "\n";
        Markov::Node<NodeStorageType>* srcN;
        Markov::Node<NodeStorageType>* targetN;
        Markov::Edge<NodeStorageType>* e;
        if (this->nodes.find(src) == this->nodes.end()) {
            srcN = new Markov::Node<NodeStorageType>(src);
            this->nodes.insert(std::pair<char, Markov::Node<NodeStorageType>*>(src, srcN));
            //std::cout << "Creating new node at start.\n";
        }
        else {
            srcN = this->nodes.find(src)->second;
        }
 
        if (this->nodes.find(target) == this->nodes.end()) {
            targetN = new Markov::Node<NodeStorageType>(target);
            this->nodes.insert(std::pair<char, Markov::Node<NodeStorageType>*>(target, targetN));
            //std::cout << "Creating new node at end.\n";
        }
        else {
            targetN = this->nodes.find(target)->second;
        }
        e = srcN->Link(targetN);
        e->AdjustEdge(oc);
        this->edges.push_back(e);
 
        //std::cout << int(srcN->NodeValue()) << " --" << e->EdgeWeight() << "--> " << int(targetN->NodeValue()) << "\n";
 
 
    }
 
    this->OptimizeEdgeOrder();
 
    return true;
}

Import() [6/8]

bool Markov::Model< char >::Import ( std::ifstream *  f )

inherited

Import a file to construct the model.

File contains a list of edges. For more info on the file format, check out the wiki and github readme pages. Format is: Left_repr;EdgeWeight;right_repr

Iterate over this list, and construct nodes and edges accordingly.

Returns

True if successful, False for incomplete models or corrupt file formats

Example Use: Import a file from ifstream

Markov::Model<char> model;
std::ifstream file("test.mdl");
model.Import(&file);

Definition at line 126 of file model.h.

                                                        {
    std::string cell;
 
    char src;
    char target;
    long int oc;
 
    while (std::getline(*f, cell)) {
        //std::cout << "cell: " << cell << std::endl;
        src = cell[0];
        target = cell[cell.length() - 1];
        char* j;
        oc = std::strtol(cell.substr(2, cell.length() - 2).c_str(),&j,10);
        //std::cout << oc << "\n";
        Markov::Node<NodeStorageType>* srcN;
        Markov::Node<NodeStorageType>* targetN;
        Markov::Edge<NodeStorageType>* e;
        if (this->nodes.find(src) == this->nodes.end()) {
            srcN = new Markov::Node<NodeStorageType>(src);
            this->nodes.insert(std::pair<char, Markov::Node<NodeStorageType>*>(src, srcN));
            //std::cout << "Creating new node at start.\n";
        }
        else {
            srcN = this->nodes.find(src)->second;
        }
 
        if (this->nodes.find(target) == this->nodes.end()) {
            targetN = new Markov::Node<NodeStorageType>(target);
            this->nodes.insert(std::pair<char, Markov::Node<NodeStorageType>*>(target, targetN));
            //std::cout << "Creating new node at end.\n";
        }
        else {
            targetN = this->nodes.find(target)->second;
        }
        e = srcN->Link(targetN);
        e->AdjustEdge(oc);
        this->edges.push_back(e);
 
        //std::cout << int(srcN->NodeValue()) << " --" << e->EdgeWeight() << "--> " << int(targetN->NodeValue()) << "\n";
 
 
    }
 
    this->OptimizeEdgeOrder();
 
    return true;
}

Import() [7/8]

bool Markov::Model< char >::Import ( std::ifstream *  f )

inherited

Import a file to construct the model.

File contains a list of edges. For more info on the file format, check out the wiki and github readme pages. Format is: Left_repr;EdgeWeight;right_repr

Iterate over this list, and construct nodes and edges accordingly.

Returns

True if successful, False for incomplete models or corrupt file formats

Example Use: Import a file from ifstream

Markov::Model<char> model;
std::ifstream file("test.mdl");
model.Import(&file);

Definition at line 126 of file model.h.

                                                        {
    std::string cell;
 
    char src;
    char target;
    long int oc;
 
    while (std::getline(*f, cell)) {
        //std::cout << "cell: " << cell << std::endl;
        src = cell[0];
        target = cell[cell.length() - 1];
        char* j;
        oc = std::strtol(cell.substr(2, cell.length() - 2).c_str(),&j,10);
        //std::cout << oc << "\n";
        Markov::Node<NodeStorageType>* srcN;
        Markov::Node<NodeStorageType>* targetN;
        Markov::Edge<NodeStorageType>* e;
        if (this->nodes.find(src) == this->nodes.end()) {
            srcN = new Markov::Node<NodeStorageType>(src);
            this->nodes.insert(std::pair<char, Markov::Node<NodeStorageType>*>(src, srcN));
            //std::cout << "Creating new node at start.\n";
        }
        else {
            srcN = this->nodes.find(src)->second;
        }
 
        if (this->nodes.find(target) == this->nodes.end()) {
            targetN = new Markov::Node<NodeStorageType>(target);
            this->nodes.insert(std::pair<char, Markov::Node<NodeStorageType>*>(target, targetN));
            //std::cout << "Creating new node at end.\n";
        }
        else {
            targetN = this->nodes.find(target)->second;
        }
        e = srcN->Link(targetN);
        e->AdjustEdge(oc);
        this->edges.push_back(e);
 
        //std::cout << int(srcN->NodeValue()) << " --" << e->EdgeWeight() << "--> " << int(targetN->NodeValue()) << "\n";
 
 
    }
 
    this->OptimizeEdgeOrder();
 
    return true;
}

Import() [8/8]

def Python.Markopy.MarkovModel.Import ( str  filename )

inherited

Definition at line 22 of file mm.py.

    def Import(filename : str):
        pass
 

import_model() [1/6]

def Python.Markopy.BaseCLI.import_model (   self, str  filename  )

inherited

Import a model file.

Parameters

filename

filename to import

Definition at line 77 of file base.py.

    def import_model(self, filename : str):
        """! 
        @brief Import a model file
        @param filename filename to import
        """
        logging.pprint("Importing model file.", 1)
 
        if not self.check_import_path(filename):
            logging.pprint(f"Model file at {filename} not found. Check the file path, or working directory")
            return False
 
        self.model.Import(filename)
        logging.pprint("Model imported successfully.", 2)
        return True
 
 
 

References Python.Markopy.BaseCLI.check_import_path(), Python.CudaMarkopy.CudaModelMatrixCLI.model, Python.Markopy.BaseCLI.model, Python.Markopy.ModelMatrixCLI.model, Python.Markopy.MarkovPasswordsCLI.model, and Markov::GUI::MarkovPasswordsGUI.model().

Referenced by Python.Markopy.BaseCLI.process().

Here is the call graph for this function:

Here is the caller graph for this function:

import_model() [2/6]

def Python.Markopy.BaseCLI.import_model (   self, str  filename  )

inherited

Import a model file.

Parameters

filename

filename to import

Definition at line 77 of file base.py.

    def import_model(self, filename : str):
        """! 
        @brief Import a model file
        @param filename filename to import
        """
        logging.pprint("Importing model file.", 1)
 
        if not self.check_import_path(filename):
            logging.pprint(f"Model file at {filename} not found. Check the file path, or working directory")
            return False
 
        self.model.Import(filename)
        logging.pprint("Model imported successfully.", 2)
        return True
 
 
 

References Python.Markopy.BaseCLI.check_import_path(), Python.CudaMarkopy.CudaModelMatrixCLI.model, Python.Markopy.BaseCLI.model, Python.Markopy.ModelMatrixCLI.model, Python.Markopy.MarkovPasswordsCLI.model, and Markov::GUI::MarkovPasswordsGUI.model().

Referenced by Python.Markopy.BaseCLI.process().

Here is the call graph for this function:

Here is the caller graph for this function:

import_model() [3/6]

def Python.Markopy.BaseCLI.import_model (   self, str  filename  )

inherited

Import a model file.

Parameters

filename

filename to import

Definition at line 77 of file base.py.

    def import_model(self, filename : str):
        """! 
        @brief Import a model file
        @param filename filename to import
        """
        logging.pprint("Importing model file.", 1)
 
        if not self.check_import_path(filename):
            logging.pprint(f"Model file at {filename} not found. Check the file path, or working directory")
            return False
 
        self.model.Import(filename)
        logging.pprint("Model imported successfully.", 2)
        return True
 
 
 

References Python.Markopy.BaseCLI.check_import_path(), Python.CudaMarkopy.CudaModelMatrixCLI.model, Python.Markopy.BaseCLI.model, Python.Markopy.ModelMatrixCLI.model, Python.Markopy.MarkovPasswordsCLI.model, and Markov::GUI::MarkovPasswordsGUI.model().

Referenced by Python.Markopy.BaseCLI.process().

Here is the call graph for this function:

Here is the caller graph for this function:

import_model() [4/6]

def Python.Markopy.BaseCLI.import_model (   self, str  filename  )

inherited

Import a model file.

Parameters

filename

filename to import

Definition at line 77 of file base.py.

    def import_model(self, filename : str):
        """! 
        @brief Import a model file
        @param filename filename to import
        """
        logging.pprint("Importing model file.", 1)
 
        if not self.check_import_path(filename):
            logging.pprint(f"Model file at {filename} not found. Check the file path, or working directory")
            return False
 
        self.model.Import(filename)
        logging.pprint("Model imported successfully.", 2)
        return True
 
 
 

References Python.Markopy.BaseCLI.check_import_path(), Python.CudaMarkopy.CudaModelMatrixCLI.model, Python.Markopy.BaseCLI.model, Python.Markopy.ModelMatrixCLI.model, Python.Markopy.MarkovPasswordsCLI.model, and Markov::GUI::MarkovPasswordsGUI.model().

Referenced by Python.Markopy.BaseCLI.process().

Here is the call graph for this function:

Here is the caller graph for this function:

import_model() [5/6]

def Python.Markopy.BaseCLI.import_model (   self, str  filename  )

inherited

Import a model file.

Parameters

filename

filename to import

Definition at line 77 of file base.py.

    def import_model(self, filename : str):
        """! 
        @brief Import a model file
        @param filename filename to import
        """
        logging.pprint("Importing model file.", 1)
 
        if not self.check_import_path(filename):
            logging.pprint(f"Model file at {filename} not found. Check the file path, or working directory")
            return False
 
        self.model.Import(filename)
        logging.pprint("Model imported successfully.", 2)
        return True
 
 
 

References Python.Markopy.BaseCLI.check_import_path(), Python.CudaMarkopy.CudaModelMatrixCLI.model, Python.Markopy.BaseCLI.model, Python.Markopy.ModelMatrixCLI.model, Python.Markopy.MarkovPasswordsCLI.model, and Markov::GUI::MarkovPasswordsGUI.model().

Referenced by Python.Markopy.BaseCLI.process().

Here is the call graph for this function:

Here is the caller graph for this function:

import_model() [6/6]

def Python.Markopy.BaseCLI.import_model (   self, str  filename  )

inherited

Import a model file.

Parameters

filename

filename to import

Definition at line 77 of file base.py.

    def import_model(self, filename : str):
        """! 
        @brief Import a model file
        @param filename filename to import
        """
        logging.pprint("Importing model file.", 1)
 
        if not self.check_import_path(filename):
            logging.pprint(f"Model file at {filename} not found. Check the file path, or working directory")
            return False
 
        self.model.Import(filename)
        logging.pprint("Model imported successfully.", 2)
        return True
 
 
 

References Python.Markopy.BaseCLI.check_import_path(), Python.CudaMarkopy.CudaModelMatrixCLI.model, Python.Markopy.BaseCLI.model, Python.Markopy.ModelMatrixCLI.model, Python.Markopy.MarkovPasswordsCLI.model, and Markov::GUI::MarkovPasswordsGUI.model().

Referenced by Python.Markopy.BaseCLI.process().

Here is the call graph for this function:

Here is the caller graph for this function:

init_post_arguments() [1/3]

def Python.Markopy.MarkopyCLI.init_post_arguments (   sel )

inherited

Reimplemented from Python.Markopy.BaseCLI.

Definition at line 175 of file markopy.py.

    def init_post_arguments(sel):
        pass
 

References Python.Markopy.MarkopyCLI.init_post_arguments().

Referenced by Python.Markopy.BaseCLI.parse(), and Python.Markopy.MarkopyCLI.parse().

Here is the call graph for this function:

Here is the caller graph for this function:

init_post_arguments() [2/3]

def Python.CudaMarkopy.CudaModelMatrixCLI.init_post_arguments (   self )

inherited

Reimplemented from Python.Markopy.ModelMatrixCLI.

Definition at line 71 of file cudammx.py.

    def init_post_arguments(self):
        super().init_post_arguments()
        self.bInfinite = self.args.infinite
        

Referenced by Python.Markopy.BaseCLI.parse(), and Python.Markopy.MarkopyCLI.parse().

Here is the caller graph for this function:

init_post_arguments() [3/3]

def Python.Markopy.MarkopyCLI.init_post_arguments (   self )

inherited

Reimplemented from Python.Markopy.BaseCLI.

Definition at line 145 of file markopy.py.

    def init_post_arguments(self):
        pass
 

Referenced by Python.Markopy.MarkopyCLI.init_post_arguments(), Python.Markopy.BaseCLI.parse(), and Python.Markopy.MarkopyCLI.parse().

Here is the caller graph for this function:

LaunchAsyncKernel()

__host__ void Markov::API::CUDA::CUDAModelMatrix::LaunchAsyncKernel ( int  kernelID, int  minLen, int  maxLen  )

protectedinherited

Definition at line 171 of file cudaModelMatrix.cu.

                                                                                                     {
 
        //if(kernelID == 0);// cudaStreamSynchronize(this->cudastreams[2]);
        //else cudaStreamSynchronize(this->cudastreams[kernelID-1]);
        FastRandomWalkCUDAKernel<<<cudaBlocks,cudaThreads,0, this->cudastreams[kernelID]>>>(iterationsPerKernelThread, minLen, maxLen, this->device_outputBuffer[kernelID], this->device_matrixIndex,
            this->device_totalEdgeWeights, this->device_valueMatrix, this->device_edgeMatrix, this->matrixSize, cudaMemPerGrid, this->device_seeds[kernelID]);
        //std::cerr << "Started kernel" << kernelID << "\n";
    }

ListCudaDevices()

__host__ void Markov::API::CUDA::CUDADeviceController::ListCudaDevices ( )

staticinherited

List CUDA devices in the system.

This function will print details of every CUDA capable device in the system.

Example output:

Device Number: 0
Device name: GeForce RTX 2070
Memory Clock Rate (KHz): 7001000
Memory Bus Width (bits): 256
Peak Memory Bandwidth (GB/s): 448.064
Max Linear Threads: 1024

Definition at line 16 of file cudaDeviceController.cu.

                                                                     { //list cuda Capable devices on host.
        int nDevices;
        cudaGetDeviceCount(&nDevices);
        for (int i = 0; i < nDevices; i++) {
            cudaDeviceProp prop;
            cudaGetDeviceProperties(&prop, i);
            std::cerr << "Device Number: " <<  i  << "\n";
            std::cerr << "Device name: " << prop.name << "\n";
            std::cerr << "Memory Clock Rate (KHz): " << prop.memoryClockRate << "\n";
            std::cerr << "Memory Bus Width (bits): " << prop.memoryBusWidth << "\n";
            std::cerr << "Peak Memory Bandwidth (GB/s): " << 2.0 * prop.memoryClockRate * (prop.memoryBusWidth / 8) / 1.0e6 << "\n";
            std::cerr << "Max Linear Threads: " << prop.maxThreadsDim[0] << "\n";
            
        }
    }

MigrateMatrix()

__host__ void Markov::API::CUDA::CUDAModelMatrix::MigrateMatrix ( )

inherited

Migrate the class members to the VRAM.

Cannot be used without calling Markov::API::ModelMatrix::ConstructMatrix at least once. This function will manage the memory allocation and data transfer from CPU RAM to GPU VRAM.

Newly allocated VRAM pointers are set in the class member variables.

Definition at line 20 of file cudaModelMatrix.cu.

                                                             {
        cudaError_t cudastatus;
 
        cudastatus = cudaMalloc((char**)&(this->device_matrixIndex), 
            this->matrixSize*sizeof(char));
        CudaCheckNotifyErr(cudastatus, "Cuda failed to initialize device_matrixIndex.");
 
        cudastatus = cudaMalloc((long int **)&(this->device_totalEdgeWeights), this->matrixSize*sizeof(long int));
        CudaCheckNotifyErr(cudastatus, "Cuda failed to initialize device_totalEdgeWeights.");
 
        cudastatus = cudaMemcpy(this->device_matrixIndex, this->matrixIndex, 
            this->matrixSize*sizeof(char), cudaMemcpyHostToDevice);
        CudaCheckNotifyErr(cudastatus, "Cuda failed to copy to device memory. (Index)");
 
        cudastatus = cudaMemcpy(this->device_totalEdgeWeights, this->totalEdgeWeights, 
            this->matrixSize*sizeof(long int), cudaMemcpyHostToDevice);
        CudaCheckNotifyErr(cudastatus, "Cuda failed to copy to device memory. (Total Edge Values)");
 
        cudastatus = CudaMigrate2DFlat<char>(
            &(this->device_edgeMatrix), this->edgeMatrix, this->matrixSize, this->matrixSize);
        CudaCheckNotifyErr(cudastatus, "    Cuda failed to initialize edge matrix.");
 
        cudastatus = CudaMigrate2DFlat<long int>(
            &(this->device_valueMatrix), this->valueMatrix, this->matrixSize, this->matrixSize);
        CudaCheckNotifyErr(cudastatus, "    Cuda failed to initialize value matrix row.");      
 
    }

Nodes() [1/4]

std::map<char , Node<char >*>* Markov::Model< char >::Nodes ( )

inlineinherited

Return starter Node.

Returns

starter node with 00 NodeValue

Definition at line 181 of file model.h.

{ return &nodes;}

Nodes() [2/4]

std::map<char , Node<char >*>* Markov::Model< char >::Nodes ( )

inlineinherited

Return starter Node.

Returns

starter node with 00 NodeValue

Definition at line 181 of file model.h.

{ return &nodes;}

Nodes() [3/4]

std::map<char , Node<char >*>* Markov::Model< char >::Nodes ( )

inlineinherited

Return starter Node.

Returns

starter node with 00 NodeValue

Definition at line 181 of file model.h.

{ return &nodes;}

Nodes() [4/4]

std::map<char , Node<char >*>* Markov::Model< char >::Nodes ( )

inlineinherited

Return starter Node.

Returns

starter node with 00 NodeValue

Definition at line 181 of file model.h.

{ return &nodes;}

OpenDatasetFile() [1/4]

std::ifstream * Markov::API::MarkovPasswords::OpenDatasetFile ( const char *  filename )

inherited

Open dataset file and return the ifstream pointer.

Parameters

filename

- Filename to open

Returns

ifstream* to the the dataset file

Definition at line 51 of file markovPasswords.cpp.

                                                                          {
 
    std::ifstream* datasetFile;
 
    std::ifstream newFile(filename);
 
    datasetFile = &newFile;
 
    this->Import(datasetFile);
    return datasetFile;
}

References Markov::Model< NodeStorageType >::Import().

Here is the call graph for this function:

OpenDatasetFile() [2/4]

std::ifstream * Markov::API::MarkovPasswords::OpenDatasetFile ( const char *  filename )

inherited

Open dataset file and return the ifstream pointer.

Parameters

filename

- Filename to open

Returns

ifstream* to the the dataset file

Definition at line 51 of file markovPasswords.cpp.

                                                                          {
 
    std::ifstream* datasetFile;
 
    std::ifstream newFile(filename);
 
    datasetFile = &newFile;
 
    this->Import(datasetFile);
    return datasetFile;
}

References Markov::Model< NodeStorageType >::Import().

Here is the call graph for this function:

OpenDatasetFile() [3/4]

std::ifstream * Markov::API::MarkovPasswords::OpenDatasetFile ( const char *  filename )

inherited

Open dataset file and return the ifstream pointer.

Parameters

filename

- Filename to open

Returns

ifstream* to the the dataset file

Definition at line 51 of file markovPasswords.cpp.

                                                                          {
 
    std::ifstream* datasetFile;
 
    std::ifstream newFile(filename);
 
    datasetFile = &newFile;
 
    this->Import(datasetFile);
    return datasetFile;
}

References Markov::Model< NodeStorageType >::Import().

Here is the call graph for this function:

OpenDatasetFile() [4/4]

std::ifstream * Markov::API::MarkovPasswords::OpenDatasetFile ( const char *  filename )

inherited

Open dataset file and return the ifstream pointer.

Parameters

filename

- Filename to open

Returns

ifstream* to the the dataset file

Definition at line 51 of file markovPasswords.cpp.

                                                                          {
 
    std::ifstream* datasetFile;
 
    std::ifstream newFile(filename);
 
    datasetFile = &newFile;
 
    this->Import(datasetFile);
    return datasetFile;
}

References Markov::Model< NodeStorageType >::Import().

Here is the call graph for this function:

OptimizeEdgeOrder() [1/4]

void Markov::Model< char >::OptimizeEdgeOrder

inherited

Sort edges of all nodes in the model ordered by edge weights.

Definition at line 186 of file model.h.

                                                    {
    for (std::pair<unsigned char, Markov::Node<NodeStorageType>*> const& x : this->nodes) {
        //std::cout << "Total edges in EdgesV: " << x.second->edgesV.size() << "\n"; 
        std::sort (x.second->edgesV.begin(), x.second->edgesV.end(), [](Edge<NodeStorageType> *lhs, Edge<NodeStorageType> *rhs)->bool{
            return lhs->EdgeWeight() > rhs->EdgeWeight();
        });
        //for(int i=0;i<x.second->edgesV.size();i++)
        //  std::cout << x.second->edgesV[i]->EdgeWeight() << ", ";
        //std::cout << "\n";
    }
    //std::cout << "Total number of nodes: " << this->nodes.size() << std::endl;
    //std::cout << "Total number of edges: " << this->edges.size() << std::endl;
}

OptimizeEdgeOrder() [2/4]

void Markov::Model< char >::OptimizeEdgeOrder

inherited

Sort edges of all nodes in the model ordered by edge weights.

Definition at line 186 of file model.h.

                                                    {
    for (std::pair<unsigned char, Markov::Node<NodeStorageType>*> const& x : this->nodes) {
        //std::cout << "Total edges in EdgesV: " << x.second->edgesV.size() << "\n"; 
        std::sort (x.second->edgesV.begin(), x.second->edgesV.end(), [](Edge<NodeStorageType> *lhs, Edge<NodeStorageType> *rhs)->bool{
            return lhs->EdgeWeight() > rhs->EdgeWeight();
        });
        //for(int i=0;i<x.second->edgesV.size();i++)
        //  std::cout << x.second->edgesV[i]->EdgeWeight() << ", ";
        //std::cout << "\n";
    }
    //std::cout << "Total number of nodes: " << this->nodes.size() << std::endl;
    //std::cout << "Total number of edges: " << this->edges.size() << std::endl;
}

OptimizeEdgeOrder() [3/4]

void Markov::Model< char >::OptimizeEdgeOrder

inherited

Sort edges of all nodes in the model ordered by edge weights.

Definition at line 186 of file model.h.

                                                    {
    for (std::pair<unsigned char, Markov::Node<NodeStorageType>*> const& x : this->nodes) {
        //std::cout << "Total edges in EdgesV: " << x.second->edgesV.size() << "\n"; 
        std::sort (x.second->edgesV.begin(), x.second->edgesV.end(), [](Edge<NodeStorageType> *lhs, Edge<NodeStorageType> *rhs)->bool{
            return lhs->EdgeWeight() > rhs->EdgeWeight();
        });
        //for(int i=0;i<x.second->edgesV.size();i++)
        //  std::cout << x.second->edgesV[i]->EdgeWeight() << ", ";
        //std::cout << "\n";
    }
    //std::cout << "Total number of nodes: " << this->nodes.size() << std::endl;
    //std::cout << "Total number of edges: " << this->edges.size() << std::endl;
}

OptimizeEdgeOrder() [4/4]

void Markov::Model< char >::OptimizeEdgeOrder

inherited

Sort edges of all nodes in the model ordered by edge weights.

Definition at line 186 of file model.h.

                                                    {
    for (std::pair<unsigned char, Markov::Node<NodeStorageType>*> const& x : this->nodes) {
        //std::cout << "Total edges in EdgesV: " << x.second->edgesV.size() << "\n"; 
        std::sort (x.second->edgesV.begin(), x.second->edgesV.end(), [](Edge<NodeStorageType> *lhs, Edge<NodeStorageType> *rhs)->bool{
            return lhs->EdgeWeight() > rhs->EdgeWeight();
        });
        //for(int i=0;i<x.second->edgesV.size();i++)
        //  std::cout << x.second->edgesV[i]->EdgeWeight() << ", ";
        //std::cout << "\n";
    }
    //std::cout << "Total number of nodes: " << this->nodes.size() << std::endl;
    //std::cout << "Total number of edges: " << this->edges.size() << std::endl;
}

parse()

def Python.CudaMarkopy.CudaMarkopyCLI.parse

(

self

)

Reimplemented from Python.Markopy.MarkopyCLI.

Definition at line 95 of file cudamarkopy.py.

    def parse(self):
        markopy.MarkopyCLI.parse(self)
 

parse_arguments() [1/6]

def Python.Markopy.BaseCLI.parse_arguments (   self )

inherited

Definition at line 73 of file base.py.

    def parse_arguments(self):
        "! @brief trigger parser"
        self.args = self.parser.parse_known_args()[0]
 

Referenced by Python.Markopy.BaseCLI.parse(), and Python.Markopy.MarkopyCLI.parse().

Here is the caller graph for this function:

parse_arguments() [2/6]

def Python.Markopy.BaseCLI.parse_arguments (   self )

inherited

Definition at line 73 of file base.py.

    def parse_arguments(self):
        "! @brief trigger parser"
        self.args = self.parser.parse_known_args()[0]
 

Referenced by Python.Markopy.BaseCLI.parse(), and Python.Markopy.MarkopyCLI.parse().

Here is the caller graph for this function:

parse_arguments() [3/6]

def Python.Markopy.BaseCLI.parse_arguments (   self )

inherited

Definition at line 73 of file base.py.

    def parse_arguments(self):
        "! @brief trigger parser"
        self.args = self.parser.parse_known_args()[0]
 

Referenced by Python.Markopy.BaseCLI.parse(), and Python.Markopy.MarkopyCLI.parse().

Here is the caller graph for this function:

parse_arguments() [4/6]

def Python.Markopy.BaseCLI.parse_arguments (   self )

inherited

Definition at line 73 of file base.py.

    def parse_arguments(self):
        "! @brief trigger parser"
        self.args = self.parser.parse_known_args()[0]
 

Referenced by Python.Markopy.BaseCLI.parse(), and Python.Markopy.MarkopyCLI.parse().

Here is the caller graph for this function:

parse_arguments() [5/6]

def Python.Markopy.BaseCLI.parse_arguments (   self )

inherited

Definition at line 73 of file base.py.

    def parse_arguments(self):
        "! @brief trigger parser"
        self.args = self.parser.parse_known_args()[0]
 

Referenced by Python.Markopy.BaseCLI.parse(), and Python.Markopy.MarkopyCLI.parse().

Here is the caller graph for this function:

parse_arguments() [6/6]

def Python.Markopy.BaseCLI.parse_arguments (   self )

inherited

Definition at line 73 of file base.py.

    def parse_arguments(self):
        "! @brief trigger parser"
        self.args = self.parser.parse_known_args()[0]
 

Referenced by Python.Markopy.BaseCLI.parse(), and Python.Markopy.MarkopyCLI.parse().

Here is the caller graph for this function:

parse_fail()

def Python.CudaMarkopy.CudaMarkopyCLI.parse_fail

(

self

)

Reimplemented from Python.Markopy.MarkopyCLI.

Definition at line 98 of file cudamarkopy.py.

    def parse_fail(self):
        "! @brief Not a valid model type"
        if(self.args.model_type == "CUDA"):
            self.cli = CudaModelMatrixCLI()
        else:
            markopy.MarkopyCLI.parse_fail(self)
        
 

References Python.CudaMarkopy.CudaMarkopyCLI.args, Python.Markopy.BaseCLI.args, and Python.Markopy.MarkopyCLI.args.

prepKernelMemoryChannel()

__host__ void Markov::API::CUDA::CUDAModelMatrix::prepKernelMemoryChannel ( int  numberOfStreams )

protectedinherited

Definition at line 145 of file cudaModelMatrix.cu.

                                                                                          {
        
        this->cudastreams = new cudaStream_t[numberOfStreams];
        for(int i=0;i<numberOfStreams;i++)
            cudaStreamCreate(&this->cudastreams[i]);
 
        this-> outputBuffer = new char*[numberOfStreams];
        for(int i=0;i<numberOfStreams;i++)
            this->outputBuffer[i]= new char[cudaPerKernelAllocationSize];
 
        cudaError_t cudastatus;
        this-> device_outputBuffer = new char*[numberOfStreams];
            for(int i=0;i<numberOfStreams;i++){
                cudastatus = cudaMalloc((char**)&(device_outputBuffer[i]), cudaPerKernelAllocationSize);
                CudaCheckNotifyErr(cudastatus, "Failed to establish memory channel. Possibly out of VRAM?");
            }
 
        this-> device_seeds = new unsigned long*[numberOfStreams];
        for(int i=0;i<numberOfStreams;i++){
            Markov::API::CUDA::Random::Marsaglia *MEarr = new Markov::API::CUDA::Random::Marsaglia[cudaGridSize];
            this->device_seeds[i] = Markov::API::CUDA::Random::Marsaglia::MigrateToVRAM(MEarr, cudaGridSize);
            delete[] MEarr;
        }
 
    }

References Markov::API::CUDA::CUDAModelMatrix::cudaGridSize, Markov::API::CUDA::CUDAModelMatrix::cudaPerKernelAllocationSize, Markov::API::CUDA::CUDAModelMatrix::device_outputBuffer, Markov::API::CUDA::CUDAModelMatrix::device_seeds, Markov::API::CUDA::Random::Marsaglia::MigrateToVRAM(), and Markov::API::CUDA::CUDAModelMatrix::outputBuffer.

Here is the call graph for this function:

process()

def Python.Markopy.MarkopyCLI.process (   self )

inherited

Process parameters for operation.

Reimplemented from Python.Markopy.BaseCLI.

Definition at line 154 of file markopy.py.

    def process(self):
        "! @brief pass the process request to selected submodel"
        return self.cli.process()
 

References Python.CudaMarkopy.CudaMarkopyCLI.cli, and Python.Markopy.MarkopyCLI.cli.

RandomWalk() [1/4]

char * Markov::Model< char >::RandomWalk ( Markov::Random::RandomEngine *  randomEngine, int  minSetting, int  maxSetting, NodeStorageType *  buffer  )

inherited

Do a random walk on this model.

Start from the starter node, on each node, invoke RandomNext using the random engine on current node, until terminator node is reached. If terminator node is reached before minimum length criateria is reached, ignore the last selection and re-invoke randomNext

If maximum length criteria is reached but final node is not, cut off the generation and proceed to the final node. This function takes Markov::Random::RandomEngine as a parameter to generate pseudo random numbers from

This library is shipped with two random engines, Marsaglia and Mersenne. While mersenne output is higher in entropy, most use cases don't really need super high entropy output, so Markov::Random::Marsaglia is preferable for better performance.

This function WILL NOT reallocate buffer. Make sure no out of bound writes are happening via maximum length criteria.

Example Use: Generate 10 lines, with 5 to 10 characters, and print the output. Use Marsaglia

Markov::Model<char> model;
Model.import("model.mdl");
char* res = new char[11];
Markov::Random::Marsaglia MarsagliaRandomEngine;
for (int i = 0; i < 10; i++) {
    this->RandomWalk(&MarsagliaRandomEngine, 5, 10, res); 
    std::cout << res << "\n";
 }

Parameters

randomEngine	Random Engine to use for the random walks. For examples, see Markov::Random::Mersenne and Markov::Random::Marsaglia
minSetting	Minimum number of characters to generate
maxSetting	Maximum number of character to generate
buffer	buffer to write the result to

Returns

Null terminated string that was generated.

Definition at line 86 of file model.h.

                                                                                                                                                         {
    Markov::Node<NodeStorageType>* n = this->starterNode;
    int len = 0;
    Markov::Node<NodeStorageType>* temp_node;
    while (true) {
        temp_node = n->RandomNext(randomEngine);
        if (len >= maxSetting) {
            break;
        }
        else if ((temp_node == NULL) && (len < minSetting)) {
            continue;
        }
 
        else if (temp_node == NULL){
            break;
        }
            
        n = temp_node;
 
        buffer[len++] = n->NodeValue();
    }
 
    //null terminate the string
    buffer[len] = 0x00;
 
    //do something with the generated string
    return buffer; //for now
}

RandomWalk() [2/4]

char * Markov::Model< char >::RandomWalk ( Markov::Random::RandomEngine *  randomEngine, int  minSetting, int  maxSetting, NodeStorageType *  buffer  )

inherited

Do a random walk on this model.

Start from the starter node, on each node, invoke RandomNext using the random engine on current node, until terminator node is reached. If terminator node is reached before minimum length criateria is reached, ignore the last selection and re-invoke randomNext

If maximum length criteria is reached but final node is not, cut off the generation and proceed to the final node. This function takes Markov::Random::RandomEngine as a parameter to generate pseudo random numbers from

This library is shipped with two random engines, Marsaglia and Mersenne. While mersenne output is higher in entropy, most use cases don't really need super high entropy output, so Markov::Random::Marsaglia is preferable for better performance.

This function WILL NOT reallocate buffer. Make sure no out of bound writes are happening via maximum length criteria.

Example Use: Generate 10 lines, with 5 to 10 characters, and print the output. Use Marsaglia

Markov::Model<char> model;
Model.import("model.mdl");
char* res = new char[11];
Markov::Random::Marsaglia MarsagliaRandomEngine;
for (int i = 0; i < 10; i++) {
    this->RandomWalk(&MarsagliaRandomEngine, 5, 10, res); 
    std::cout << res << "\n";
 }

Parameters

randomEngine	Random Engine to use for the random walks. For examples, see Markov::Random::Mersenne and Markov::Random::Marsaglia
minSetting	Minimum number of characters to generate
maxSetting	Maximum number of character to generate
buffer	buffer to write the result to

Returns

Null terminated string that was generated.

Definition at line 86 of file model.h.

                                                                                                                                                         {
    Markov::Node<NodeStorageType>* n = this->starterNode;
    int len = 0;
    Markov::Node<NodeStorageType>* temp_node;
    while (true) {
        temp_node = n->RandomNext(randomEngine);
        if (len >= maxSetting) {
            break;
        }
        else if ((temp_node == NULL) && (len < minSetting)) {
            continue;
        }
 
        else if (temp_node == NULL){
            break;
        }
            
        n = temp_node;
 
        buffer[len++] = n->NodeValue();
    }
 
    //null terminate the string
    buffer[len] = 0x00;
 
    //do something with the generated string
    return buffer; //for now
}

RandomWalk() [3/4]

char * Markov::Model< char >::RandomWalk ( Markov::Random::RandomEngine *  randomEngine, int  minSetting, int  maxSetting, NodeStorageType *  buffer  )

inherited

Do a random walk on this model.

Start from the starter node, on each node, invoke RandomNext using the random engine on current node, until terminator node is reached. If terminator node is reached before minimum length criateria is reached, ignore the last selection and re-invoke randomNext

If maximum length criteria is reached but final node is not, cut off the generation and proceed to the final node. This function takes Markov::Random::RandomEngine as a parameter to generate pseudo random numbers from

This library is shipped with two random engines, Marsaglia and Mersenne. While mersenne output is higher in entropy, most use cases don't really need super high entropy output, so Markov::Random::Marsaglia is preferable for better performance.

This function WILL NOT reallocate buffer. Make sure no out of bound writes are happening via maximum length criteria.

Example Use: Generate 10 lines, with 5 to 10 characters, and print the output. Use Marsaglia

Markov::Model<char> model;
Model.import("model.mdl");
char* res = new char[11];
Markov::Random::Marsaglia MarsagliaRandomEngine;
for (int i = 0; i < 10; i++) {
    this->RandomWalk(&MarsagliaRandomEngine, 5, 10, res); 
    std::cout << res << "\n";
 }

Parameters

randomEngine	Random Engine to use for the random walks. For examples, see Markov::Random::Mersenne and Markov::Random::Marsaglia
minSetting	Minimum number of characters to generate
maxSetting	Maximum number of character to generate
buffer	buffer to write the result to

Returns

Null terminated string that was generated.

Definition at line 86 of file model.h.

                                                                                                                                                         {
    Markov::Node<NodeStorageType>* n = this->starterNode;
    int len = 0;
    Markov::Node<NodeStorageType>* temp_node;
    while (true) {
        temp_node = n->RandomNext(randomEngine);
        if (len >= maxSetting) {
            break;
        }
        else if ((temp_node == NULL) && (len < minSetting)) {
            continue;
        }
 
        else if (temp_node == NULL){
            break;
        }
            
        n = temp_node;
 
        buffer[len++] = n->NodeValue();
    }
 
    //null terminate the string
    buffer[len] = 0x00;
 
    //do something with the generated string
    return buffer; //for now
}

RandomWalk() [4/4]

char * Markov::Model< char >::RandomWalk ( Markov::Random::RandomEngine *  randomEngine, int  minSetting, int  maxSetting, NodeStorageType *  buffer  )

inherited

Do a random walk on this model.

Start from the starter node, on each node, invoke RandomNext using the random engine on current node, until terminator node is reached. If terminator node is reached before minimum length criateria is reached, ignore the last selection and re-invoke randomNext

If maximum length criteria is reached but final node is not, cut off the generation and proceed to the final node. This function takes Markov::Random::RandomEngine as a parameter to generate pseudo random numbers from

This library is shipped with two random engines, Marsaglia and Mersenne. While mersenne output is higher in entropy, most use cases don't really need super high entropy output, so Markov::Random::Marsaglia is preferable for better performance.

This function WILL NOT reallocate buffer. Make sure no out of bound writes are happening via maximum length criteria.

Example Use: Generate 10 lines, with 5 to 10 characters, and print the output. Use Marsaglia

Markov::Model<char> model;
Model.import("model.mdl");
char* res = new char[11];
Markov::Random::Marsaglia MarsagliaRandomEngine;
for (int i = 0; i < 10; i++) {
    this->RandomWalk(&MarsagliaRandomEngine, 5, 10, res); 
    std::cout << res << "\n";
 }

Parameters

randomEngine	Random Engine to use for the random walks. For examples, see Markov::Random::Mersenne and Markov::Random::Marsaglia
minSetting	Minimum number of characters to generate
maxSetting	Maximum number of character to generate
buffer	buffer to write the result to

Returns

Null terminated string that was generated.

Definition at line 86 of file model.h.

                                                                                                                                                         {
    Markov::Node<NodeStorageType>* n = this->starterNode;
    int len = 0;
    Markov::Node<NodeStorageType>* temp_node;
    while (true) {
        temp_node = n->RandomNext(randomEngine);
        if (len >= maxSetting) {
            break;
        }
        else if ((temp_node == NULL) && (len < minSetting)) {
            continue;
        }
 
        else if (temp_node == NULL){
            break;
        }
            
        n = temp_node;
 
        buffer[len++] = n->NodeValue();
    }
 
    //null terminate the string
    buffer[len] = 0x00;
 
    //do something with the generated string
    return buffer; //for now
}

Save() [1/4]

std::ofstream * Markov::API::MarkovPasswords::Save ( const char *  filename )

inherited

Export model to file.

Parameters

filename

- Export filename.

Returns

std::ofstream* of the exported file.

Definition at line 106 of file markovPasswords.cpp.

                                                                {
    std::ofstream* exportFile;
 
    std::ofstream newFile(filename);
 
    exportFile = &newFile;
    
    this->Export(exportFile);
    return exportFile;
}

References Markov::Model< NodeStorageType >::Export().

Here is the call graph for this function:

Save() [2/4]

std::ofstream * Markov::API::MarkovPasswords::Save ( const char *  filename )

inherited

Export model to file.

Parameters

filename

- Export filename.

Returns

std::ofstream* of the exported file.

Definition at line 106 of file markovPasswords.cpp.

                                                                {
    std::ofstream* exportFile;
 
    std::ofstream newFile(filename);
 
    exportFile = &newFile;
    
    this->Export(exportFile);
    return exportFile;
}

References Markov::Model< NodeStorageType >::Export().

Here is the call graph for this function:

Save() [3/4]

std::ofstream * Markov::API::MarkovPasswords::Save ( const char *  filename )

inherited

Export model to file.

Parameters

filename

- Export filename.

Returns

std::ofstream* of the exported file.

Definition at line 106 of file markovPasswords.cpp.

                                                                {
    std::ofstream* exportFile;
 
    std::ofstream newFile(filename);
 
    exportFile = &newFile;
    
    this->Export(exportFile);
    return exportFile;
}

References Markov::Model< NodeStorageType >::Export().

Here is the call graph for this function:

Save() [4/4]

std::ofstream * Markov::API::MarkovPasswords::Save ( const char *  filename )

inherited

Export model to file.

Parameters

filename

- Export filename.

Returns

std::ofstream* of the exported file.

Definition at line 106 of file markovPasswords.cpp.

                                                                {
    std::ofstream* exportFile;
 
    std::ofstream newFile(filename);
 
    exportFile = &newFile;
    
    this->Export(exportFile);
    return exportFile;
}

References Markov::Model< NodeStorageType >::Export().

Here is the call graph for this function:

StarterNode() [1/4]

Node<char >* Markov::Model< char >::StarterNode ( )

inlineinherited

Return starter Node.

Returns

starter node with 00 NodeValue

Definition at line 171 of file model.h.

{ return starterNode;}

StarterNode() [2/4]

Node<char >* Markov::Model< char >::StarterNode ( )

inlineinherited

Return starter Node.

Returns

starter node with 00 NodeValue

Definition at line 171 of file model.h.

{ return starterNode;}

StarterNode() [3/4]

Node<char >* Markov::Model< char >::StarterNode ( )

inlineinherited

Return starter Node.

Returns

starter node with 00 NodeValue

Definition at line 171 of file model.h.

{ return starterNode;}

StarterNode() [4/4]

Node<char >* Markov::Model< char >::StarterNode ( )

inlineinherited

Return starter Node.

Returns

starter node with 00 NodeValue

Definition at line 171 of file model.h.

{ return starterNode;}

stub()

def Python.Markopy.MarkopyCLI.stub (   self )

inherited

Definition at line 158 of file markopy.py.

    def stub(self):
        "! @brief stub function to hack help requests"
        return
        
    

Referenced by Python.CudaMarkopy.CudaMarkopyCLI.help(), and Python.Markopy.MarkopyCLI.help().

Here is the caller graph for this function:

Train() [1/4]

void Markov::API::ModelMatrix::Train ( const char *  datasetFileName, char  delimiter, int  threads  )

inherited

Train the model with the dataset file.

Parameters

datasetFileName	- Ifstream* to the dataset. If null, use class member
delimiter	- a character, same as the delimiter in dataset content
threads	- number of OS threads to spawn

Markov::API::MarkovPasswords mp;
mp.Import("models/2gram.mdl");
mp.Train("password.corpus");

Construct the matrix when done.

Definition at line 25 of file modelMatrix.cpp.

                                                                                        {
    this->DeallocateMatrix();
    this->Markov::API::MarkovPasswords::Train(datasetFileName,delimiter,threads);
    this->ConstructMatrix();
}

References Markov::API::ModelMatrix::ConstructMatrix(), Markov::API::ModelMatrix::DeallocateMatrix(), and Markov::API::MarkovPasswords::Train().

Referenced by Markov::Markopy::CUDA::BOOST_PYTHON_MODULE(), and Markov::Markopy::BOOST_PYTHON_MODULE().

Here is the call graph for this function:

Here is the caller graph for this function:

Train() [2/4]

void Markov::API::ModelMatrix::Train ( const char *  datasetFileName, char  delimiter, int  threads  )

inherited

Train the model with the dataset file.

Parameters

datasetFileName	- Ifstream* to the dataset. If null, use class member
delimiter	- a character, same as the delimiter in dataset content
threads	- number of OS threads to spawn

Markov::API::MarkovPasswords mp;
mp.Import("models/2gram.mdl");
mp.Train("password.corpus");

Construct the matrix when done.

Definition at line 25 of file modelMatrix.cpp.

                                                                                        {
    this->DeallocateMatrix();
    this->Markov::API::MarkovPasswords::Train(datasetFileName,delimiter,threads);
    this->ConstructMatrix();
}

References Markov::API::ModelMatrix::ConstructMatrix(), Markov::API::ModelMatrix::DeallocateMatrix(), and Markov::API::MarkovPasswords::Train().

Referenced by Markov::Markopy::CUDA::BOOST_PYTHON_MODULE(), and Markov::Markopy::BOOST_PYTHON_MODULE().

Here is the call graph for this function:

Here is the caller graph for this function:

Train() [3/4]

void Markov::API::ModelMatrix::Train ( const char *  datasetFileName, char  delimiter, int  threads  )

inherited

Train the model with the dataset file.

Parameters

datasetFileName	- Ifstream* to the dataset. If null, use class member
delimiter	- a character, same as the delimiter in dataset content
threads	- number of OS threads to spawn

Markov::API::MarkovPasswords mp;
mp.Import("models/2gram.mdl");
mp.Train("password.corpus");

Construct the matrix when done.

Definition at line 25 of file modelMatrix.cpp.

                                                                                        {
    this->DeallocateMatrix();
    this->Markov::API::MarkovPasswords::Train(datasetFileName,delimiter,threads);
    this->ConstructMatrix();
}

References Markov::API::ModelMatrix::ConstructMatrix(), Markov::API::ModelMatrix::DeallocateMatrix(), and Markov::API::MarkovPasswords::Train().

Referenced by Markov::Markopy::CUDA::BOOST_PYTHON_MODULE(), and Markov::Markopy::BOOST_PYTHON_MODULE().

Here is the call graph for this function:

Here is the caller graph for this function:

train() [1/6]

def Python.Markopy.BaseCLI.train (   self, str  dataset, str  seperator, str  output, bool  output_forced = False, bool  bulk = False  )

inherited

Train a model via CLI parameters.

Parameters

model	Model instance
dataset	filename for the dataset
seperator	seperator used with the dataset
output	output filename
output_forced	force overwrite
bulk	marks bulk operation with directories

Definition at line 94 of file base.py.

    def train(self, dataset : str, seperator : str, output : str, output_forced : bool=False, bulk : bool=False):
        """! 
            @brief Train a model via CLI parameters 
            @param model Model instance
            @param dataset filename for the dataset
            @param seperator seperator used with the dataset
            @param output output filename
            @param output_forced force overwrite
            @param bulk marks bulk operation with directories
        """
        logging.pprint("Training.")
 
        if not (dataset and seperator and (output or not output_forced)):
            logging.pprint(f"Training mode requires -d/--dataset{', -o/--output' if output_forced else''} and -s/--seperator parameters. Exiting.")
            return False
 
        if not bulk and not self.check_corpus_path(dataset):
            logging.pprint(f"{dataset} doesn't exists. Check the file path, or working directory")
            return False
 
        if not self.check_export_path(output):
            logging.pprint(f"Cannot create output at {output}")
            return False
 
        if(seperator == '\\t'):
            logging.pprint("Escaping seperator.", 3)
            seperator = '\t'
        
        if(len(seperator)!=1):
            logging.pprint(f'Delimiter must be a single character, and "{seperator}" is not accepted.')
            exit(4)
 
        logging.pprint(f'Starting training.', 3)
        self.model.Train(dataset,seperator, int(self.args.threads))
        logging.pprint(f'Training completed.', 2)
 
        if(output):
            logging.pprint(f'Exporting model to {output}', 2)
            self.export(output)
        else:
            logging.pprint(f'Model will not be exported.', 1)
 
        return True
 

References Python.CudaMarkopy.CudaMarkopyCLI.args, Python.Markopy.BaseCLI.args, Python.Markopy.MarkopyCLI.args, Python.Markopy.BaseCLI.check_corpus_path(), Python.Markopy.BaseCLI.check_export_path(), Python.Markopy.BaseCLI.export(), Python.CudaMarkopy.CudaModelMatrixCLI.model, Python.Markopy.BaseCLI.model, Python.Markopy.ModelMatrixCLI.model, Python.Markopy.MarkovPasswordsCLI.model, and Markov::GUI::MarkovPasswordsGUI.model().

Referenced by Python.Markopy.BaseCLI.process().

Here is the call graph for this function:

Here is the caller graph for this function:

train() [2/6]

def Python.Markopy.BaseCLI.train (   self, str  dataset, str  seperator, str  output, bool  output_forced = False, bool  bulk = False  )

inherited

Train a model via CLI parameters.

Parameters

model	Model instance
dataset	filename for the dataset
seperator	seperator used with the dataset
output	output filename
output_forced	force overwrite
bulk	marks bulk operation with directories

Definition at line 94 of file base.py.

    def train(self, dataset : str, seperator : str, output : str, output_forced : bool=False, bulk : bool=False):
        """! 
            @brief Train a model via CLI parameters 
            @param model Model instance
            @param dataset filename for the dataset
            @param seperator seperator used with the dataset
            @param output output filename
            @param output_forced force overwrite
            @param bulk marks bulk operation with directories
        """
        logging.pprint("Training.")
 
        if not (dataset and seperator and (output or not output_forced)):
            logging.pprint(f"Training mode requires -d/--dataset{', -o/--output' if output_forced else''} and -s/--seperator parameters. Exiting.")
            return False
 
        if not bulk and not self.check_corpus_path(dataset):
            logging.pprint(f"{dataset} doesn't exists. Check the file path, or working directory")
            return False
 
        if not self.check_export_path(output):
            logging.pprint(f"Cannot create output at {output}")
            return False
 
        if(seperator == '\\t'):
            logging.pprint("Escaping seperator.", 3)
            seperator = '\t'
        
        if(len(seperator)!=1):
            logging.pprint(f'Delimiter must be a single character, and "{seperator}" is not accepted.')
            exit(4)
 
        logging.pprint(f'Starting training.', 3)
        self.model.Train(dataset,seperator, int(self.args.threads))
        logging.pprint(f'Training completed.', 2)
 
        if(output):
            logging.pprint(f'Exporting model to {output}', 2)
            self.export(output)
        else:
            logging.pprint(f'Model will not be exported.', 1)
 
        return True
 

References Python.CudaMarkopy.CudaMarkopyCLI.args, Python.Markopy.BaseCLI.args, Python.Markopy.MarkopyCLI.args, Python.Markopy.BaseCLI.check_corpus_path(), Python.Markopy.BaseCLI.check_export_path(), Python.Markopy.BaseCLI.export(), Python.CudaMarkopy.CudaModelMatrixCLI.model, Python.Markopy.BaseCLI.model, Python.Markopy.ModelMatrixCLI.model, Python.Markopy.MarkovPasswordsCLI.model, and Markov::GUI::MarkovPasswordsGUI.model().

Referenced by Python.Markopy.BaseCLI.process().

Here is the call graph for this function:

Here is the caller graph for this function:

train() [3/6]

def Python.Markopy.BaseCLI.train (   self, str  dataset, str  seperator, str  output, bool  output_forced = False, bool  bulk = False  )

inherited

Train a model via CLI parameters.

Parameters

model	Model instance
dataset	filename for the dataset
seperator	seperator used with the dataset
output	output filename
output_forced	force overwrite
bulk	marks bulk operation with directories

Definition at line 94 of file base.py.

    def train(self, dataset : str, seperator : str, output : str, output_forced : bool=False, bulk : bool=False):
        """! 
            @brief Train a model via CLI parameters 
            @param model Model instance
            @param dataset filename for the dataset
            @param seperator seperator used with the dataset
            @param output output filename
            @param output_forced force overwrite
            @param bulk marks bulk operation with directories
        """
        logging.pprint("Training.")
 
        if not (dataset and seperator and (output or not output_forced)):
            logging.pprint(f"Training mode requires -d/--dataset{', -o/--output' if output_forced else''} and -s/--seperator parameters. Exiting.")
            return False
 
        if not bulk and not self.check_corpus_path(dataset):
            logging.pprint(f"{dataset} doesn't exists. Check the file path, or working directory")
            return False
 
        if not self.check_export_path(output):
            logging.pprint(f"Cannot create output at {output}")
            return False
 
        if(seperator == '\\t'):
            logging.pprint("Escaping seperator.", 3)
            seperator = '\t'
        
        if(len(seperator)!=1):
            logging.pprint(f'Delimiter must be a single character, and "{seperator}" is not accepted.')
            exit(4)
 
        logging.pprint(f'Starting training.', 3)
        self.model.Train(dataset,seperator, int(self.args.threads))
        logging.pprint(f'Training completed.', 2)
 
        if(output):
            logging.pprint(f'Exporting model to {output}', 2)
            self.export(output)
        else:
            logging.pprint(f'Model will not be exported.', 1)
 
        return True
 

References Python.CudaMarkopy.CudaMarkopyCLI.args, Python.Markopy.BaseCLI.args, Python.Markopy.MarkopyCLI.args, Python.Markopy.BaseCLI.check_corpus_path(), Python.Markopy.BaseCLI.check_export_path(), Python.Markopy.BaseCLI.export(), Python.CudaMarkopy.CudaModelMatrixCLI.model, Python.Markopy.BaseCLI.model, Python.Markopy.ModelMatrixCLI.model, Python.Markopy.MarkovPasswordsCLI.model, and Markov::GUI::MarkovPasswordsGUI.model().

Referenced by Python.Markopy.BaseCLI.process().

Here is the call graph for this function:

Here is the caller graph for this function:

train() [4/6]

def Python.Markopy.BaseCLI.train (   self, str  dataset, str  seperator, str  output, bool  output_forced = False, bool  bulk = False  )

inherited

Train a model via CLI parameters.

Parameters

model	Model instance
dataset	filename for the dataset
seperator	seperator used with the dataset
output	output filename
output_forced	force overwrite
bulk	marks bulk operation with directories

Definition at line 94 of file base.py.

    def train(self, dataset : str, seperator : str, output : str, output_forced : bool=False, bulk : bool=False):
        """! 
            @brief Train a model via CLI parameters 
            @param model Model instance
            @param dataset filename for the dataset
            @param seperator seperator used with the dataset
            @param output output filename
            @param output_forced force overwrite
            @param bulk marks bulk operation with directories
        """
        logging.pprint("Training.")
 
        if not (dataset and seperator and (output or not output_forced)):
            logging.pprint(f"Training mode requires -d/--dataset{', -o/--output' if output_forced else''} and -s/--seperator parameters. Exiting.")
            return False
 
        if not bulk and not self.check_corpus_path(dataset):
            logging.pprint(f"{dataset} doesn't exists. Check the file path, or working directory")
            return False
 
        if not self.check_export_path(output):
            logging.pprint(f"Cannot create output at {output}")
            return False
 
        if(seperator == '\\t'):
            logging.pprint("Escaping seperator.", 3)
            seperator = '\t'
        
        if(len(seperator)!=1):
            logging.pprint(f'Delimiter must be a single character, and "{seperator}" is not accepted.')
            exit(4)
 
        logging.pprint(f'Starting training.', 3)
        self.model.Train(dataset,seperator, int(self.args.threads))
        logging.pprint(f'Training completed.', 2)
 
        if(output):
            logging.pprint(f'Exporting model to {output}', 2)
            self.export(output)
        else:
            logging.pprint(f'Model will not be exported.', 1)
 
        return True
 

References Python.CudaMarkopy.CudaMarkopyCLI.args, Python.Markopy.BaseCLI.args, Python.Markopy.MarkopyCLI.args, Python.Markopy.BaseCLI.check_corpus_path(), Python.Markopy.BaseCLI.check_export_path(), Python.Markopy.BaseCLI.export(), Python.CudaMarkopy.CudaModelMatrixCLI.model, Python.Markopy.BaseCLI.model, Python.Markopy.ModelMatrixCLI.model, Python.Markopy.MarkovPasswordsCLI.model, and Markov::GUI::MarkovPasswordsGUI.model().

Referenced by Python.Markopy.BaseCLI.process().

Here is the call graph for this function:

Here is the caller graph for this function:

train() [5/6]

def Python.Markopy.BaseCLI.train (   self, str  dataset, str  seperator, str  output, bool  output_forced = False, bool  bulk = False  )

inherited

Train a model via CLI parameters.

Parameters

model	Model instance
dataset	filename for the dataset
seperator	seperator used with the dataset
output	output filename
output_forced	force overwrite
bulk	marks bulk operation with directories

Definition at line 94 of file base.py.

    def train(self, dataset : str, seperator : str, output : str, output_forced : bool=False, bulk : bool=False):
        """! 
            @brief Train a model via CLI parameters 
            @param model Model instance
            @param dataset filename for the dataset
            @param seperator seperator used with the dataset
            @param output output filename
            @param output_forced force overwrite
            @param bulk marks bulk operation with directories
        """
        logging.pprint("Training.")
 
        if not (dataset and seperator and (output or not output_forced)):
            logging.pprint(f"Training mode requires -d/--dataset{', -o/--output' if output_forced else''} and -s/--seperator parameters. Exiting.")
            return False
 
        if not bulk and not self.check_corpus_path(dataset):
            logging.pprint(f"{dataset} doesn't exists. Check the file path, or working directory")
            return False
 
        if not self.check_export_path(output):
            logging.pprint(f"Cannot create output at {output}")
            return False
 
        if(seperator == '\\t'):
            logging.pprint("Escaping seperator.", 3)
            seperator = '\t'
        
        if(len(seperator)!=1):
            logging.pprint(f'Delimiter must be a single character, and "{seperator}" is not accepted.')
            exit(4)
 
        logging.pprint(f'Starting training.', 3)
        self.model.Train(dataset,seperator, int(self.args.threads))
        logging.pprint(f'Training completed.', 2)
 
        if(output):
            logging.pprint(f'Exporting model to {output}', 2)
            self.export(output)
        else:
            logging.pprint(f'Model will not be exported.', 1)
 
        return True
 

References Python.CudaMarkopy.CudaMarkopyCLI.args, Python.Markopy.BaseCLI.args, Python.Markopy.MarkopyCLI.args, Python.Markopy.BaseCLI.check_corpus_path(), Python.Markopy.BaseCLI.check_export_path(), Python.Markopy.BaseCLI.export(), Python.CudaMarkopy.CudaModelMatrixCLI.model, Python.Markopy.BaseCLI.model, Python.Markopy.ModelMatrixCLI.model, Python.Markopy.MarkovPasswordsCLI.model, and Markov::GUI::MarkovPasswordsGUI.model().

Referenced by Python.Markopy.BaseCLI.process().

Here is the call graph for this function:

Here is the caller graph for this function:

train() [6/6]

def Python.Markopy.BaseCLI.train (   self, str  dataset, str  seperator, str  output, bool  output_forced = False, bool  bulk = False  )

inherited

Train a model via CLI parameters.

Parameters

model	Model instance
dataset	filename for the dataset
seperator	seperator used with the dataset
output	output filename
output_forced	force overwrite
bulk	marks bulk operation with directories

Definition at line 94 of file base.py.

    def train(self, dataset : str, seperator : str, output : str, output_forced : bool=False, bulk : bool=False):
        """! 
            @brief Train a model via CLI parameters 
            @param model Model instance
            @param dataset filename for the dataset
            @param seperator seperator used with the dataset
            @param output output filename
            @param output_forced force overwrite
            @param bulk marks bulk operation with directories
        """
        logging.pprint("Training.")
 
        if not (dataset and seperator and (output or not output_forced)):
            logging.pprint(f"Training mode requires -d/--dataset{', -o/--output' if output_forced else''} and -s/--seperator parameters. Exiting.")
            return False
 
        if not bulk and not self.check_corpus_path(dataset):
            logging.pprint(f"{dataset} doesn't exists. Check the file path, or working directory")
            return False
 
        if not self.check_export_path(output):
            logging.pprint(f"Cannot create output at {output}")
            return False
 
        if(seperator == '\\t'):
            logging.pprint("Escaping seperator.", 3)
            seperator = '\t'
        
        if(len(seperator)!=1):
            logging.pprint(f'Delimiter must be a single character, and "{seperator}" is not accepted.')
            exit(4)
 
        logging.pprint(f'Starting training.', 3)
        self.model.Train(dataset,seperator, int(self.args.threads))
        logging.pprint(f'Training completed.', 2)
 
        if(output):
            logging.pprint(f'Exporting model to {output}', 2)
            self.export(output)
        else:
            logging.pprint(f'Model will not be exported.', 1)
 
        return True
 

References Python.CudaMarkopy.CudaMarkopyCLI.args, Python.Markopy.BaseCLI.args, Python.Markopy.MarkopyCLI.args, Python.Markopy.BaseCLI.check_corpus_path(), Python.Markopy.BaseCLI.check_export_path(), Python.Markopy.BaseCLI.export(), Python.CudaMarkopy.CudaModelMatrixCLI.model, Python.Markopy.BaseCLI.model, Python.Markopy.ModelMatrixCLI.model, Python.Markopy.MarkovPasswordsCLI.model, and Markov::GUI::MarkovPasswordsGUI.model().

Referenced by Python.Markopy.BaseCLI.process().

Here is the call graph for this function:

Here is the caller graph for this function:

Train() [4/4]

def Python.Markopy.MarkovModel.Train ( str  dataset, str  seperator, int  threads  )

inherited

Definition at line 30 of file mm.py.

    def Train(dataset: str, seperator : str, threads : int):
        pass
 

TrainThread()

void Markov::API::MarkovPasswords::TrainThread ( Markov::API::Concurrency::ThreadSharedListHandler *  listhandler, char  delimiter  )

privateinherited

A single thread invoked by the Train function.

Parameters

listhandler	- Listhandler class to read corpus from
delimiter	- a character, same as the delimiter in dataset content

Definition at line 85 of file markovPasswords.cpp.

                                                                                                                  {
    char format_str[] ="%ld,%s";
    format_str[3]=delimiter;
    std::string line;
    while (listhandler->next(&line) && keepRunning) {
        long int oc;
        if (line.size() > 100) {
            line = line.substr(0, 100);
        }
        char* linebuf = new char[line.length()+5];
#ifdef _WIN32
        sscanf_s(line.c_str(), "%ld,%s", &oc, linebuf, line.length()+5); //<== changed format_str to-> "%ld,%s"
#else
        sscanf(line.c_str(), format_str, &oc, linebuf);
#endif
        this->AdjustEdge((const char*)linebuf, oc); 
        delete linebuf;
    }
}

References Markov::Model< NodeStorageType >::AdjustEdge(), keepRunning, and Markov::API::Concurrency::ThreadSharedListHandler::next().

Referenced by Markov::API::MarkovPasswords::Train().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

alternatingKernels

int Markov::API::CUDA::CUDAModelMatrix::alternatingKernels

privateinherited

Definition at line 135 of file cudaModelMatrix.h.

Referenced by Markov::API::CUDA::CUDAModelMatrix::FastRandomWalk().

args

Python.CudaMarkopy.CudaMarkopyCLI.args

Definition at line 64 of file cudamarkopy.py.

Referenced by Python.CudaMarkopy.CudaModelMatrixCLI._generate(), Python.Markopy.BaseCLI._generate(), Python.Markopy.ModelMatrixCLI._generate(), Python.Markopy.MarkovPasswordsCLI._generate(), Python.Markopy.BaseCLI.generate(), Python.Markopy.MarkopyCLI.help(), Python.Markopy.BaseCLI.init_post_arguments(), Python.Markopy.MarkopyCLI.parse(), Python.CudaMarkopy.CudaMarkopyCLI.parse_fail(), Python.Markopy.BaseCLI.process(), and Python.Markopy.BaseCLI.train().

bInfinite

Python.CudaMarkopy.CudaModelMatrixCLI.bInfinite

inherited

Definition at line 73 of file cudammx.py.

Referenced by Python.CudaMarkopy.CudaModelMatrixCLI._generate().

cli

Python.CudaMarkopy.CudaMarkopyCLI.cli

Definition at line 101 of file cudamarkopy.py.

Referenced by Python.Markopy.MarkopyCLI.process().

cudaBlocks

int Markov::API::CUDA::CUDAModelMatrix::cudaBlocks

privateinherited

Definition at line 125 of file cudaModelMatrix.h.

Referenced by Markov::API::CUDA::CUDAModelMatrix::FastRandomWalk().

cudaGridSize

int Markov::API::CUDA::CUDAModelMatrix::cudaGridSize

privateinherited

Definition at line 131 of file cudaModelMatrix.h.

Referenced by Markov::API::CUDA::CUDAModelMatrix::FastRandomWalk(), and Markov::API::CUDA::CUDAModelMatrix::prepKernelMemoryChannel().

cudaMemPerGrid

int Markov::API::CUDA::CUDAModelMatrix::cudaMemPerGrid

privateinherited

Definition at line 132 of file cudaModelMatrix.h.

Referenced by Markov::API::CUDA::CUDAModelMatrix::FastRandomWalk(), and Markov::API::CUDA::CUDAModelMatrix::GatherAsyncKernelOutput().

cudaPerKernelAllocationSize

long int Markov::API::CUDA::CUDAModelMatrix::cudaPerKernelAllocationSize

privateinherited

Definition at line 133 of file cudaModelMatrix.h.

Referenced by Markov::API::CUDA::CUDAModelMatrix::FastRandomWalk(), Markov::API::CUDA::CUDAModelMatrix::GatherAsyncKernelOutput(), and Markov::API::CUDA::CUDAModelMatrix::prepKernelMemoryChannel().

cudastreams

cudaStream_t* Markov::API::CUDA::CUDAModelMatrix::cudastreams

privateinherited

Definition at line 139 of file cudaModelMatrix.h.

cudaThreads

int Markov::API::CUDA::CUDAModelMatrix::cudaThreads

privateinherited

Definition at line 126 of file cudaModelMatrix.h.

Referenced by Markov::API::CUDA::CUDAModelMatrix::FastRandomWalk().

datasetFile

std::ifstream* Markov::API::MarkovPasswords::datasetFile

privateinherited

Definition at line 123 of file markovPasswords.h.

device_edgeMatrix

char* Markov::API::CUDA::CUDAModelMatrix::device_edgeMatrix

privateinherited

VRAM Address pointer of edge matrix (from modelMatrix.h)

Definition at line 88 of file cudaModelMatrix.h.

device_matrixIndex

char* Markov::API::CUDA::CUDAModelMatrix::device_matrixIndex

privateinherited

VRAM Address pointer of matrixIndex (from modelMatrix.h)

Definition at line 98 of file cudaModelMatrix.h.

device_outputBuffer

char** Markov::API::CUDA::CUDAModelMatrix::device_outputBuffer

privateinherited

RandomWalk results in device.

Definition at line 108 of file cudaModelMatrix.h.

Referenced by Markov::API::CUDA::CUDAModelMatrix::prepKernelMemoryChannel().

device_seeds

unsigned long** Markov::API::CUDA::CUDAModelMatrix::device_seeds

privateinherited

Definition at line 137 of file cudaModelMatrix.h.

Referenced by Markov::API::CUDA::CUDAModelMatrix::prepKernelMemoryChannel().

device_totalEdgeWeights

long int* Markov::API::CUDA::CUDAModelMatrix::device_totalEdgeWeights

privateinherited

VRAM Address pointer of total edge weights (from modelMatrix.h)

Definition at line 103 of file cudaModelMatrix.h.

device_valueMatrix

long int* Markov::API::CUDA::CUDAModelMatrix::device_valueMatrix

privateinherited

VRAM Address pointer of value matrix (from modelMatrix.h)

Definition at line 93 of file cudaModelMatrix.h.

edgeMatrix [1/3]

char** Markov::API::ModelMatrix::edgeMatrix

protectedinherited

2-D Character array for the edge Matrix (The characters of Nodes)

Definition at line 175 of file modelMatrix.h.

Referenced by Markov::API::ModelMatrix::ConstructMatrix(), Markov::API::ModelMatrix::DeallocateMatrix(), Markov::API::ModelMatrix::DumpJSON(), and Markov::API::ModelMatrix::FastRandomWalkThread().

edgeMatrix [2/3]

char** Markov::API::ModelMatrix::edgeMatrix

protectedinherited

2-D Character array for the edge Matrix (The characters of Nodes)

Definition at line 175 of file modelMatrix.h.

Referenced by Markov::API::ModelMatrix::ConstructMatrix(), Markov::API::ModelMatrix::DeallocateMatrix(), Markov::API::ModelMatrix::DumpJSON(), and Markov::API::ModelMatrix::FastRandomWalkThread().

edgeMatrix [3/3]

char** Markov::API::ModelMatrix::edgeMatrix

protectedinherited

2-D Character array for the edge Matrix (The characters of Nodes)

Definition at line 175 of file modelMatrix.h.

Referenced by Markov::API::ModelMatrix::ConstructMatrix(), Markov::API::ModelMatrix::DeallocateMatrix(), Markov::API::ModelMatrix::DumpJSON(), and Markov::API::ModelMatrix::FastRandomWalkThread().

edges

std::vector<Edge<char >*> Markov::Model< char >::edges

privateinherited

A list of all edges in this model.

Definition at line 204 of file model.h.

fileIO [1/2]

Python.Markopy.ModelMatrixCLI.fileIO

inherited

Definition at line 38 of file mmx.py.

Referenced by Python.CudaMarkopy.CudaModelMatrixCLI._generate(), and Python.Markopy.ModelMatrixCLI._generate().

fileIO [2/2]

Python.Markopy.ModelMatrixCLI.fileIO

inherited

Definition at line 38 of file mmx.py.

Referenced by Python.CudaMarkopy.CudaModelMatrixCLI._generate(), and Python.Markopy.ModelMatrixCLI._generate().

flatEdgeMatrix

char* Markov::API::CUDA::CUDAModelMatrix::flatEdgeMatrix

privateinherited

Adding Edge matrix end-to-end and resize to 1-D array for better perfomance on traversing.

Definition at line 118 of file cudaModelMatrix.h.

Referenced by Markov::API::CUDA::CUDAModelMatrix::FlattenMatrix().

flatValueMatrix

long int* Markov::API::CUDA::CUDAModelMatrix::flatValueMatrix

privateinherited

Adding Value matrix end-to-end and resize to 1-D array for better perfomance on traversing.

Definition at line 123 of file cudaModelMatrix.h.

Referenced by Markov::API::CUDA::CUDAModelMatrix::FlattenMatrix().

iterationsPerKernelThread

int Markov::API::CUDA::CUDAModelMatrix::iterationsPerKernelThread

privateinherited

Definition at line 127 of file cudaModelMatrix.h.

Referenced by Markov::API::CUDA::CUDAModelMatrix::FastRandomWalk().

matrixIndex [1/3]

char* Markov::API::ModelMatrix::matrixIndex

protectedinherited

to hold the Matrix index (To hold the orders of 2-D arrays')

Definition at line 190 of file modelMatrix.h.

Referenced by Markov::API::ModelMatrix::ConstructMatrix(), Markov::API::ModelMatrix::DeallocateMatrix(), Markov::API::ModelMatrix::DumpJSON(), and Markov::API::ModelMatrix::FastRandomWalkThread().

matrixIndex [2/3]

char* Markov::API::ModelMatrix::matrixIndex

protectedinherited

to hold the Matrix index (To hold the orders of 2-D arrays')

Definition at line 190 of file modelMatrix.h.

Referenced by Markov::API::ModelMatrix::ConstructMatrix(), Markov::API::ModelMatrix::DeallocateMatrix(), Markov::API::ModelMatrix::DumpJSON(), and Markov::API::ModelMatrix::FastRandomWalkThread().

matrixIndex [3/3]

char* Markov::API::ModelMatrix::matrixIndex

protectedinherited

to hold the Matrix index (To hold the orders of 2-D arrays')

Definition at line 190 of file modelMatrix.h.

Referenced by Markov::API::ModelMatrix::ConstructMatrix(), Markov::API::ModelMatrix::DeallocateMatrix(), Markov::API::ModelMatrix::DumpJSON(), and Markov::API::ModelMatrix::FastRandomWalkThread().

matrixSize [1/3]

int Markov::API::ModelMatrix::matrixSize

protectedinherited

to hold Matrix size

Definition at line 185 of file modelMatrix.h.

Referenced by Markov::API::ModelMatrix::ConstructMatrix(), Markov::API::ModelMatrix::DeallocateMatrix(), Markov::API::ModelMatrix::DumpJSON(), Markov::API::ModelMatrix::FastRandomWalkThread(), and Markov::API::CUDA::CUDAModelMatrix::FlattenMatrix().

matrixSize [2/3]

int Markov::API::ModelMatrix::matrixSize

protectedinherited

to hold Matrix size

Definition at line 185 of file modelMatrix.h.

Referenced by Markov::API::ModelMatrix::ConstructMatrix(), Markov::API::ModelMatrix::DeallocateMatrix(), Markov::API::ModelMatrix::DumpJSON(), Markov::API::ModelMatrix::FastRandomWalkThread(), and Markov::API::CUDA::CUDAModelMatrix::FlattenMatrix().

matrixSize [3/3]

int Markov::API::ModelMatrix::matrixSize

protectedinherited

to hold Matrix size

Definition at line 185 of file modelMatrix.h.

Referenced by Markov::API::ModelMatrix::ConstructMatrix(), Markov::API::ModelMatrix::DeallocateMatrix(), Markov::API::ModelMatrix::DumpJSON(), Markov::API::ModelMatrix::FastRandomWalkThread(), and Markov::API::CUDA::CUDAModelMatrix::FlattenMatrix().

model [1/4]

Python.CudaMarkopy.CudaModelMatrixCLI.model

inherited

Definition at line 65 of file cudammx.py.

Referenced by Python.CudaMarkopy.CudaModelMatrixCLI._generate(), Python.Markopy.BaseCLI._generate(), Python.Markopy.ModelMatrixCLI._generate(), Python.Markopy.MarkovPasswordsCLI._generate(), Python.Markopy.BaseCLI.export(), Python.Markopy.BaseCLI.import_model(), and Python.Markopy.BaseCLI.train().

model [2/4]

Python.Markopy.BaseCLI.model

inherited

Definition at line 40 of file base.py.

Referenced by Python.CudaMarkopy.CudaModelMatrixCLI._generate(), Python.Markopy.BaseCLI._generate(), Python.Markopy.ModelMatrixCLI._generate(), Python.Markopy.MarkovPasswordsCLI._generate(), Python.Markopy.BaseCLI.export(), Python.Markopy.BaseCLI.import_model(), and Python.Markopy.BaseCLI.train().

model [3/4]

Python.Markopy.ModelMatrixCLI.model

inherited

Definition at line 30 of file mmx.py.

Referenced by Python.CudaMarkopy.CudaModelMatrixCLI._generate(), Python.Markopy.BaseCLI._generate(), Python.Markopy.ModelMatrixCLI._generate(), Python.Markopy.MarkovPasswordsCLI._generate(), Python.Markopy.BaseCLI.export(), Python.Markopy.BaseCLI.import_model(), and Python.Markopy.BaseCLI.train().

model [4/4]

Python.Markopy.MarkovPasswordsCLI.model

inherited

Definition at line 29 of file mp.py.

Referenced by Python.CudaMarkopy.CudaModelMatrixCLI._generate(), Python.Markopy.BaseCLI._generate(), Python.Markopy.ModelMatrixCLI._generate(), Python.Markopy.MarkovPasswordsCLI._generate(), Python.Markopy.BaseCLI.export(), Python.Markopy.BaseCLI.import_model(), and Python.Markopy.BaseCLI.train().

modelSavefile

std::ofstream* Markov::API::MarkovPasswords::modelSavefile

privateinherited

Dataset file input of our system

Definition at line 124 of file markovPasswords.h.

nodes

std::map<char , Node<char >*> Markov::Model< char >::nodes

privateinherited

Map LeftNode is the Nodes NodeValue Map RightNode is the node pointer.

Definition at line 193 of file model.h.

numberOfPartitions

int Markov::API::CUDA::CUDAModelMatrix::numberOfPartitions

privateinherited

Definition at line 130 of file cudaModelMatrix.h.

Referenced by Markov::API::CUDA::CUDAModelMatrix::FastRandomWalk().

outputBuffer

char** Markov::API::CUDA::CUDAModelMatrix::outputBuffer

privateinherited

RandomWalk results in host.

Definition at line 113 of file cudaModelMatrix.h.

Referenced by Markov::API::CUDA::CUDAModelMatrix::GatherAsyncKernelOutput(), and Markov::API::CUDA::CUDAModelMatrix::prepKernelMemoryChannel().

outputFile

std::ofstream* Markov::API::MarkovPasswords::outputFile

privateinherited

File to save model of our system

Definition at line 125 of file markovPasswords.h.

parser [1/6]

Python.Markopy.BaseCLI.parser

inherited

Definition at line 25 of file base.py.

Referenced by Python.CudaMarkopy.CudaMarkopyCLI.__init__(), Python.CudaMarkopy.CudaModelMatrixCLI.add_arguments(), Python.Markopy.BaseCLI.add_arguments(), Python.Markopy.AbstractGenerationModelCLI.add_arguments(), Python.Markopy.AbstractTrainingModelCLI.add_arguments(), Python.Markopy.MarkopyCLI.add_arguments(), Python.Markopy.ModelMatrixCLI.add_arguments(), Python.CudaMarkopy.CudaMarkopyCLI.help(), and Python.Markopy.MarkopyCLI.help().

parser [2/6]

Python.Markopy.BaseCLI.parser

inherited

Definition at line 25 of file base.py.

Referenced by Python.CudaMarkopy.CudaMarkopyCLI.__init__(), Python.CudaMarkopy.CudaModelMatrixCLI.add_arguments(), Python.Markopy.BaseCLI.add_arguments(), Python.Markopy.AbstractGenerationModelCLI.add_arguments(), Python.Markopy.AbstractTrainingModelCLI.add_arguments(), Python.Markopy.MarkopyCLI.add_arguments(), Python.Markopy.ModelMatrixCLI.add_arguments(), Python.CudaMarkopy.CudaMarkopyCLI.help(), and Python.Markopy.MarkopyCLI.help().

parser [3/6]

Python.Markopy.BaseCLI.parser

inherited

Definition at line 25 of file base.py.

Referenced by Python.CudaMarkopy.CudaMarkopyCLI.__init__(), Python.CudaMarkopy.CudaModelMatrixCLI.add_arguments(), Python.Markopy.BaseCLI.add_arguments(), Python.Markopy.AbstractGenerationModelCLI.add_arguments(), Python.Markopy.AbstractTrainingModelCLI.add_arguments(), Python.Markopy.MarkopyCLI.add_arguments(), Python.Markopy.ModelMatrixCLI.add_arguments(), Python.CudaMarkopy.CudaMarkopyCLI.help(), and Python.Markopy.MarkopyCLI.help().

parser [4/6]

Python.Markopy.BaseCLI.parser

inherited

Definition at line 25 of file base.py.

Referenced by Python.CudaMarkopy.CudaMarkopyCLI.__init__(), Python.CudaMarkopy.CudaModelMatrixCLI.add_arguments(), Python.Markopy.BaseCLI.add_arguments(), Python.Markopy.AbstractGenerationModelCLI.add_arguments(), Python.Markopy.AbstractTrainingModelCLI.add_arguments(), Python.Markopy.MarkopyCLI.add_arguments(), Python.Markopy.ModelMatrixCLI.add_arguments(), Python.CudaMarkopy.CudaMarkopyCLI.help(), and Python.Markopy.MarkopyCLI.help().

parser [5/6]

Python.Markopy.BaseCLI.parser

inherited

Definition at line 25 of file base.py.

Referenced by Python.CudaMarkopy.CudaMarkopyCLI.__init__(), Python.CudaMarkopy.CudaModelMatrixCLI.add_arguments(), Python.Markopy.BaseCLI.add_arguments(), Python.Markopy.AbstractGenerationModelCLI.add_arguments(), Python.Markopy.AbstractTrainingModelCLI.add_arguments(), Python.Markopy.MarkopyCLI.add_arguments(), Python.Markopy.ModelMatrixCLI.add_arguments(), Python.CudaMarkopy.CudaMarkopyCLI.help(), and Python.Markopy.MarkopyCLI.help().

parser [6/6]

Python.Markopy.BaseCLI.parser

inherited

Definition at line 25 of file base.py.

Referenced by Python.CudaMarkopy.CudaMarkopyCLI.__init__(), Python.CudaMarkopy.CudaModelMatrixCLI.add_arguments(), Python.Markopy.BaseCLI.add_arguments(), Python.Markopy.AbstractGenerationModelCLI.add_arguments(), Python.Markopy.AbstractTrainingModelCLI.add_arguments(), Python.Markopy.MarkopyCLI.add_arguments(), Python.Markopy.ModelMatrixCLI.add_arguments(), Python.CudaMarkopy.CudaMarkopyCLI.help(), and Python.Markopy.MarkopyCLI.help().

print_help [1/6]

Python.Markopy.BaseCLI.print_help

inherited

Definition at line 39 of file base.py.

Referenced by Python.Markopy.BaseCLI.help(), and Python.Markopy.MarkopyCLI.help().

print_help [2/6]

Python.Markopy.BaseCLI.print_help

inherited

Definition at line 39 of file base.py.

Referenced by Python.Markopy.BaseCLI.help(), and Python.Markopy.MarkopyCLI.help().

print_help [3/6]

Python.Markopy.BaseCLI.print_help

inherited

Definition at line 39 of file base.py.

Referenced by Python.Markopy.BaseCLI.help(), and Python.Markopy.MarkopyCLI.help().

print_help [4/6]

Python.Markopy.BaseCLI.print_help

inherited

Definition at line 39 of file base.py.

Referenced by Python.Markopy.BaseCLI.help(), and Python.Markopy.MarkopyCLI.help().

print_help [5/6]

Python.Markopy.BaseCLI.print_help

inherited

Definition at line 39 of file base.py.

Referenced by Python.Markopy.BaseCLI.help(), and Python.Markopy.MarkopyCLI.help().

print_help [6/6]

Python.Markopy.BaseCLI.print_help

inherited

Definition at line 39 of file base.py.

Referenced by Python.Markopy.BaseCLI.help(), and Python.Markopy.MarkopyCLI.help().

ready [1/3]

bool Markov::API::ModelMatrix::ready

protectedinherited

True when matrix is constructed. False if not.

Definition at line 200 of file modelMatrix.h.

Referenced by Markov::API::ModelMatrix::ConstructMatrix(), Markov::API::ModelMatrix::DeallocateMatrix(), and Markov::API::ModelMatrix::ModelMatrix().

ready [2/3]

bool Markov::API::ModelMatrix::ready

protectedinherited

True when matrix is constructed. False if not.

Definition at line 200 of file modelMatrix.h.

Referenced by Markov::API::ModelMatrix::ConstructMatrix(), Markov::API::ModelMatrix::DeallocateMatrix(), and Markov::API::ModelMatrix::ModelMatrix().

ready [3/3]

bool Markov::API::ModelMatrix::ready

protectedinherited

True when matrix is constructed. False if not.

Definition at line 200 of file modelMatrix.h.

Referenced by Markov::API::ModelMatrix::ConstructMatrix(), Markov::API::ModelMatrix::DeallocateMatrix(), and Markov::API::ModelMatrix::ModelMatrix().

starterNode

Node<char >* Markov::Model< char >::starterNode

privateinherited

Starter Node of this model.

Definition at line 198 of file model.h.

totalEdgeWeights [1/3]

long int* Markov::API::ModelMatrix::totalEdgeWeights

protectedinherited

Array of the Total Edge Weights.

Definition at line 195 of file modelMatrix.h.

Referenced by Markov::API::ModelMatrix::ConstructMatrix(), Markov::API::ModelMatrix::DeallocateMatrix(), and Markov::API::ModelMatrix::FastRandomWalkThread().

totalEdgeWeights [2/3]

long int* Markov::API::ModelMatrix::totalEdgeWeights

protectedinherited

Array of the Total Edge Weights.

Definition at line 195 of file modelMatrix.h.

Referenced by Markov::API::ModelMatrix::ConstructMatrix(), Markov::API::ModelMatrix::DeallocateMatrix(), and Markov::API::ModelMatrix::FastRandomWalkThread().

totalEdgeWeights [3/3]

long int* Markov::API::ModelMatrix::totalEdgeWeights

protectedinherited

Array of the Total Edge Weights.

Definition at line 195 of file modelMatrix.h.

Referenced by Markov::API::ModelMatrix::ConstructMatrix(), Markov::API::ModelMatrix::DeallocateMatrix(), and Markov::API::ModelMatrix::FastRandomWalkThread().

totalOutputPerKernel

long int Markov::API::CUDA::CUDAModelMatrix::totalOutputPerKernel

privateinherited

Definition at line 129 of file cudaModelMatrix.h.

Referenced by Markov::API::CUDA::CUDAModelMatrix::FastRandomWalk().

totalOutputPerSync

long int Markov::API::CUDA::CUDAModelMatrix::totalOutputPerSync

privateinherited

Definition at line 128 of file cudaModelMatrix.h.

Referenced by Markov::API::CUDA::CUDAModelMatrix::FastRandomWalk().

valueMatrix [1/3]

long int** Markov::API::ModelMatrix::valueMatrix

protectedinherited

2-d Integer array for the value Matrix (For the weights of Edges)

Definition at line 180 of file modelMatrix.h.

Referenced by Markov::API::ModelMatrix::ConstructMatrix(), Markov::API::ModelMatrix::DeallocateMatrix(), Markov::API::ModelMatrix::DumpJSON(), and Markov::API::ModelMatrix::FastRandomWalkThread().

valueMatrix [2/3]

long int** Markov::API::ModelMatrix::valueMatrix

protectedinherited

2-d Integer array for the value Matrix (For the weights of Edges)

Definition at line 180 of file modelMatrix.h.

Referenced by Markov::API::ModelMatrix::ConstructMatrix(), Markov::API::ModelMatrix::DeallocateMatrix(), Markov::API::ModelMatrix::DumpJSON(), and Markov::API::ModelMatrix::FastRandomWalkThread().

valueMatrix [3/3]

long int** Markov::API::ModelMatrix::valueMatrix

protectedinherited

2-d Integer array for the value Matrix (For the weights of Edges)

Definition at line 180 of file modelMatrix.h.

Referenced by Markov::API::ModelMatrix::ConstructMatrix(), Markov::API::ModelMatrix::DeallocateMatrix(), Markov::API::ModelMatrix::DumpJSON(), and Markov::API::ModelMatrix::FastRandomWalkThread().

---

The documentation for this class was generated from the following file:

• Markopy/CudaMarkopy/src/CLI/cudamarkopy.py