boonnano.h

Go to the documentation of this file.

 
#pragma once
 
#include <stdio.h>
#include <cstdint>
#include <string.h>
#include <iostream>
#include "boonconfig.h"
#include "autotune.h"
#include "nanoutil.h"
#include "clusterstats.h"
 
#include <list>
#include <map>
#include <vector>
 
class CNanoBackend;             // forward declare
class CClusterStatsCollection;  // forward declare
class CTypeConverter;           // forward declare
class CSGXManager;              // forward declare
 
#ifndef MAX_BN_ERROR_STRING
#define MAX_BN_ERROR_STRING 1000
#endif
 
 
class CNanoBackendManager {
 public:
  CNanoBackendManager();
  ~CNanoBackendManager();
 
  std::string GetStatusString(int CurrentIndent = 0, int AdditionalIndent = 4);  
 
  bool InitBackend(uint16_t NBKernels = 1);  
 
  CNanoBackend* GetBackendPointer(uint16_t KernelIndex = 0);  
 
  void ReleaseBackendPointer(uint16_t KernelIndex);  
 
  int GetNextAvailableBackendIndex();  
 
  uint16_t GetNBKernels();  
 
  void GetErrorMessage(char* Message);  
 
 private:
  // functions
  void BackendRelease();
 
  // classes
  CSGXManager* m_SGXManager;  // For SGX Back ends
  std::vector<CNanoBackend*> m_NanoBackends;
  std::vector<bool> m_BackendInUse;
  uint16_t m_NumKernels, m_KernelsPerDevice;
  bool m_InitComplete;
  char m_ErrorBuffer[MAX_BN_ERROR_STRING];
};
 
 
class CBoonNano {
 public:
  CBoonNano(CNanoBackend* NanoBackend = nullptr);  
  ~CBoonNano();
 
  void Reset(bool BackendReset = true);  
 
  bool Serialize(const char* ArchivePath, bool IsLoading);  
 
  bool Serialize(const char* VarPath, const char* ThisVarName, struct archive* Archive, bool IsLoading);
 
  std::string GetStatusString(int CurrentIndent = 0, int AdditionalIndent = 4);  
 
  void SetLearningMode(bool LearningOn);  
 
  bool GetLearningMode() const;  
 
  void SetGhostClusterEnabled(bool GhostClustersEnabled);  
 
  bool GetGhostClusterEnabled() const;  
 
  void SetNanoClippingDetection(bool ClippingOn);  
 
  bool GetNanoClippingDetection() const;  
 
  bool Setup(CNanoConfigParameters& NanoConfig);  
 
  int ClusterData(float* Pattern, CClusterStats* AdvancedAnalytics = nullptr);  
 
  void ClusterData(float* PatternBuffer, uint32_t NumPatterns, int* ResultBuffer, CClusterStats* AdvancedAnalyticsBuffer = nullptr);  
 
  uint32_t ClusterData(float* PatternBuffer, uint32_t NumPatterns, int* ResultBuffer, uint32_t StepCount, CClusterStats* AdvancedAnalyticsBuffer = nullptr);  
 
  int ClusterData(int16_t* Pattern, CClusterStats* AdvancedAnalytics = nullptr);  
 
  void ClusterData(int16_t* PatternBuffer, uint32_t NumPatterns, int* ResultBuffer, CClusterStats* AdvancedAnalyticsBuffer = nullptr);  
 
  uint32_t ClusterData(int16_t* PatternBuffer, uint32_t NumPatterns, int* ResultBuffer, uint32_t StepCount, CClusterStats* AdvancedAnalyticsBuffer = nullptr);  
 
  int ClusterData(uint16_t* Pattern, CClusterStats* AdvancedAnalytics = nullptr);  
 
  void ClusterData(uint16_t* PatternBuffer, uint32_t NumPatterns, int* ResultBuffer, CClusterStats* AdvancedAnalyticsBuffer = nullptr);  
 
  uint32_t ClusterData(uint16_t* PatternBuffer, uint32_t NumPatterns, int* ResultBuffer, uint32_t StepCount, CClusterStats* AdvancedAnalyticsBuffer = nullptr);  
 
  uint16_t ProbeClusterCount(uint16_t* PatternBuffer, uint32_t NumPatterns, uint32_t MaxClusters);  
 
  uint16_t ProbeClusterCount(int16_t* PatternBuffer, uint32_t NumPatterns, uint32_t MaxClusters);  
 
  uint16_t ProbeClusterCount(float* PatternBuffer, uint32_t NumPatterns, uint32_t MaxClusters);  
 
  void ResetClusters();  
 
  bool MaxClusterCountReached();  
 
  uint16_t GetPatternLength();  
 
  bool InitComplete() const;  
 
  char* GetErrorMessage();  
 
  uint16_t GetCurrentClusterCount() const;  
 
  uint64_t GetClusterSize(int ID) const;  
 
  uint64_t GetInferenceCountWhenClusterWasCreated(int ID) const;  
 
  uint64_t GetNumOfPatternsClustered() const;  
 
  void GetPCA(int ID, uint32_t& X, uint32_t& Y, uint32_t& Z);  
 
  uint32_t GetAnomalyIndex(int ID);  
 
  uint16_t GetNoveltyIndex(int ID);  
 
  uint32_t GetFrequencyIndex(int ID);  
 
  uint32_t GetDistanceIndex(int ID);  
 
  uint32_t GetProbabilityIndex(int ID);  
 
  float GetInterClusterDistance(int ID1, int ID2);  
 
  int GetNearestNeighbor(int ID);  
 
  int GetNearestNeighbor(float* Pattern, float& Confidence);  
 
  int GetNearestNeighbor(uint16_t* Pattern, float& Confidence);  
 
  int GetNearestNeighbor(int16_t* Pattern, float& Confidence);  
 
  float GetPercentVariation() const;  
 
  uint16_t GetStreamingWindowSize() const;  
 
  uint16_t GetMaxClusters() const;  
 
  void SetMaxClusters(uint16_t MaxClusters);  
 
  bool GetRootCause(int ID, float* RootCause);  
 
  bool GetRootCause(uint8_t* Pattern, uint32_t PatternSizeInElements, float* RootCause);  
 
  CNanoConfigParameters& GetNanoConfig();  
 
  bool PruneClusterIDs(const uint32_t* IDArray, uint32_t NumIDs);  
 
  CTypeConverter* m_TypeConverter;  
 
#ifdef BOON_DIAGNOSTIC
#include "boondiagnostic.h"
#endif
 
 private:
  CNanoBackendManager* m_BackendManager;
  CNanoBackend* m_NanoBackend;
  bool m_IsNanoBackend;
  CNanoConfigParameters m_NanoConfig;
  CClusterStatsCollection* m_ClusterStatsCollection;
  char m_ErrorMsg[MAX_BN_ERROR_STRING];
  uint8_t* m_PMArray;
  bool m_NanoClippingEnabled;
};