GraphHammer.SimplestParallel

Simplest and slowest implementation for GraphHammer data structure and analyses combination. It is used for API prototyping. This version is extended with parallel execution of analyses.

Documentation

type Index = Int64

Big enough for Graph500 benchmark purposes.

HList

data Nil

Instances

HLength Nil

EnabledAnalyses Nil eas

data a :. b

Instances

EnabledAnalysis a as => EnabledAnalysis a (:. a' as)

EnabledAnalysis a (:. a as)

HLength as => HLength (:. a as)

(EnabledAnalyses as eas, EnabledAnalysis a eas) => EnabledAnalyses (:. a as) eas

Representation exported abstractly

data GraphHammer as

A representation parametrized by analyses required.

How to create a new GraphHammer.

graphHammerNew

Arguments

:: HLength as

=> Int

Max job nodes

-> Int

Node index

-> Chan SendReceive

-> Array Int32 (Chan (Msg as))

-> IO (GraphHammer as)

Create a GraphHammer structure for parallel GraphHammer processing.

An analysis monad to create operations with GraphHammer.

type GraphHammerM as a = StateT (GraphHammer as) IO a

Monad to operate with GraphHammer.

runAnalysesStack

Arguments

:: (HLength as, EnabledAnalyses as as)

=> Integer

-> Int

Max number of nodes

-> IO (Maybe (UArray Int Index))

Function to obtain edges to insert

-> Analysis as as

A stack of analyses to perform

-> IO ()

Run the analyses stack. at this momemt it's possible to run only parallelizable analyses.

Local values processing.

data Value asgn v

A (modifable) value.

Instances

Show v => Show (Value asgn v)

data Composed

localValue :: (Show v, AnalysisValue v) => v -> AnM as (Value Asgn v)

Define a local value and assign to it.

cst :: v -> Value Composed v

Constant value

($=) :: (Show v, AnalysisValue v) => Value Asgn v -> Value _a v -> AnM as ()

Assigning a value.

(+.) :: (Show v, Num v) => Value _a v -> Value _b v -> Value Composed v

(-.) :: (Show v, Num v) => Value _a v -> Value _b v -> Value Composed v

(*.) :: (Show v, Num v) => Value _a v -> Value _b v -> Value Composed v

divV :: (Integral v, Show v) => Value _a v -> Value _b v -> Value Composed v

(===) :: (Show v, Eq v) => Value _a v -> Value _b v -> Value Composed Bool

(=/=) :: (Show v, Eq v) => Value _a v -> Value _b v -> Value Composed Bool

Analysis type. Abstract.

data Analysis as wholeset

type AnM as a = State (AnSt as) a

onEdges :: Value Composed Index -> (Value Composed Index -> AnM as r) -> AnM as r

anIf :: Value Composed Bool -> AnM as r -> AnM as r -> AnM as r

getAnalysisResult :: AnalysisIndex a as => a -> Value _a Index -> AnM as (Value Composed Int64)

Fetch analysis result.

putAnalysisResult :: AnalysisIndex a as => a -> Value _a Index -> Value _b Int64 -> AnM as ()

Store analysis result.

incrementAnalysisResult :: AnalysisIndex a as => a -> Value _a Index -> Value _b Int64 -> AnM as ()

Update atomically result with increment.

type family RequiredAnalyses a

How to create basic analysis, one which does not depend on the other.

basicAnalysis :: (RequiredAnalyses a ~ Nil, EnabledAnalysis a wholeset) => a -> (a -> Value Composed Index -> Value Composed Index -> AnM (a :. Nil) ()) -> Analysis (a :. Nil) wholeset

Derived analysis, dependent on some other.

derivedAnalysis :: (EnabledAnalyses (RequiredAnalyses a) as, EnabledAnalyses as wholeset, EnabledAnalyses (a :. as) wholeset) => Analysis as wholeset -> a -> (a -> Value Composed Index -> Value Composed Index -> AnM (a :. as) ()) -> Analysis (a :. as) wholeset

class EnabledAnalysis a as

Instances

EnabledAnalysis a as => EnabledAnalysis a (:. a' as)

EnabledAnalysis a (:. a as)

class EnabledAnalyses as eas

Instances

EnabledAnalyses Nil eas

(EnabledAnalyses as eas, EnabledAnalysis a eas) => EnabledAnalyses (:. a as) eas