1 people like it.

CNTK Log File Parser

Parser for CNTK error log file (see https://www.microsoft.com/en-us/research/product/cognitive-toolkit/) tested with version 2.0 beta. The parser can be combined with other tooling such as F# chart to view live error rates, etc. (includes a unix 'tail' like function)

  1: 
  2: 
  3: 
  4: 
  5: 
  6: 
  7: 
  8: 
  9: 
 10: 
 11: 
 12: 
 13: 
 14: 
 15: 
 16: 
 17: 
 18: 
 19: 
 20: 
 21: 
 22: 
 23: 
 24: 
 25: 
 26: 
 27: 
 28: 
 29: 
 30: 
 31: 
 32: 
 33: 
 34: 
 35: 
 36: 
 37: 
 38: 
 39: 
 40: 
 41: 
 42: 
 43: 
 44: 
 45: 
 46: 
 47: 
 48: 
 49: 
 50: 
 51: 
 52: 
 53: 
 54: 
 55: 
 56: 
 57: 
 58: 
 59: 
 60: 
 61: 
 62: 
 63: 
 64: 
 65: 
 66: 
 67: 
 68: 
 69: 
 70: 
 71: 
 72: 
 73: 
 74: 
 75: 
 76: 
 77: 
 78: 
 79: 
 80: 
 81: 
 82: 
 83: 
 84: 
 85: 
 86: 
 87: 
 88: 
 89: 
 90: 
 91: 
 92: 
 93: 
 94: 
 95: 
 96: 
 97: 
 98: 
 99: 
100: 
101: 
102: 
103: 
104: 
105: 
106: 
107: 
108: 
109: 
110: 
111: 
112: 
113: 
114: 
115: 
116: 
117: 
118: 
119: 
120: 
121: 
122: 
123: 
124: 
125: 
126: 
127: 
128: 
129: 
130: 
131: 
132: 
133: 
134: 
135: 
136: 
137: 
138: 
139: 
140: 
141: 
142: 
143: 
144: 
145: 
146: 
147: 
148: 
149: 
150: 
151: 
152: 
153: 
154: 
155: 
156: 
157: 
158: 
159: 
160: 
161: 
162: 
163: 
164: 
165: 
166: 
167: 
168: 
169: 
170: 
171: 
172: 
173: 
174: 
175: 
176: 
177: 
178: 
179: 
180: 
181: 
182: 
183: 
184: 
185: 
186: 
187: 
188: 
189: 
190: 
191: 
module CNTLLogParser

type MiniBatch = 
    {
        Epoch   : int
        Epochs  : int 
        MbFrom  : int 
        MbTo    : int 
        Percent : float
        CE      : float
        Times   : float
        Err     : float
        Time    : System.TimeSpan
        SPS     : float //samples per second
        }

type EpochEnd = 
    {
        Epoch           : int
        Mode            : string //train, test
        CE              : float
        Times           : float
        Err             : float
        TotalSamples    : int
        LR              : float
        EpochTime       : System.TimeSpan
    }

type EpochStart = 
    {
        Epoch           : int
        LRSample        : float
        Momentum        : float
        MConstSamples   : float
    }

type LogMsg =
    | MB of MiniBatch 
    | EE of EpochEnd 
    | Unk of string 
    | SE of EpochStart

let delims = 
    [|
        '['; ']'; ' '; '-'; ':'; 
        '='; ';'; '*'; ','; '%'
    |]

let private parseMinibatch (l:string) =
//  let l = "Epoch[ 1 of 100]-Minibatch[18481-18490]: CE = 0.48781250 * 250; Err = 0.18800000 * 250; time = 0.0271s; samplesPerSecond = 9216.3"
//  let l =  "Epoch[83 of 100]-Minibatch[11591-11600, 62.43%]: CE = 0.55243750 * 250; Err = 0.24800000 * 250; time = 0.0344s; samplesPerSecond = 7276.3"
    let xs = l.Split(delims, System.StringSplitOptions.RemoveEmptyEntries)
// pattern 1
//  [|"Epoch";0 "1";1 "of";2 "100";3 "Minibatch";4 "18481";5 "18490";6 "CE";7
//    "0.48781250";8 "250";9 "Err";10 "0.18800000";11 "250";12 "time";13 "0.0271s";14
//    "samplesPerSecond";15 "9216.3";16|]
    if xs.[7] = "CE" then
        {
            Epoch   = int xs.[1]
            Epochs  = int xs.[3]
            MbFrom  = int xs.[5]
            MbTo    = int xs.[6]
            Percent = 0.
            CE      = float xs.[8]
            Times   = float xs.[9]
            Err     = float xs.[11]
            Time    = System.TimeSpan.FromSeconds(xs.[14].Replace("s","") |> float) //System.TimeSpan.FromSeconds("0.0271s".Replace("s","") |> float)
            SPS     = float xs.[16] //samples per second
        
        }
// pattern 2
//  [|"Epoch";0 "83";1 "of";2 "100";3 "Minibatch";4 "11591";5 "11600";6 "62.43%";7 "CE";8
//    "0.55243750";9 "250";10 "Err";11 "0.24800000";12 "250";13 "time";14 "0.0344s";15
//    "samplesPerSecond";16 "7276.3";17|]    
    else
        {
            Epoch   = int xs.[1]
            Epochs  = int xs.[3]
            MbFrom  = int xs.[5]
            MbTo    = int xs.[6]
            Percent = float xs.[7]
            CE      = float xs.[9]
            Times   = float xs.[10]
            Err     = float xs.[12]
            Time    = System.TimeSpan.FromSeconds(xs.[15].Replace("s","") |> float) //System.TimeSpan.FromSeconds("0.0271s".Replace("s","") |> float)
            SPS     = float xs.[17] //samples per second
        
        }
        
let private parseEndEpoch (l:string) =
//    let l = "Finished Epoch[21 of 100]: [Training] CE = 0.47475340 * 464505; Err = 0.19504419 * 464505; totalSamplesSeen = 9754605; learningRatePerSample = 0.0080000004; epochTime=58.2492s"
    let xs = l.Split(delims, System.StringSplitOptions.RemoveEmptyEntries)
//      [|"Finished";0 "Epoch";1 "21";2 "of";3 "100";4 "Training";5 "CE";6 "0.47475340";7
//    "464505"8; "Err";9 "0.19504419";10 "464505";11 "totalSamplesSeen"12; "9754605";13
//    "learningRatePerSample";14 "0.0080000004";15 "epochTime";16 "58.2492s";17 |]
    {
        Epoch           = int xs.[2]
        Mode            = xs.[5]
        CE              = float xs.[7]
        Times           = float xs.[8]
        Err             = float xs.[10]
        TotalSamples    = int xs.[13]
        LR              = float xs.[15]
        EpochTime       = System.TimeSpan.FromSeconds(xs.[17].Replace("s","") |> float)
    }

let private parseStartEpoch (l:string) =
//    let l = "Starting Epoch 9: learning rate per sample = 0.008000  effective momentum = 0.900000  momentum as time constant = 237.3 samples"
    let xs = l.Split(delims, System.StringSplitOptions.RemoveEmptyEntries)
//    [|"Starting";0 "Epoch";1 "9";2 "learning";3 "rate";4 "per";5 "sample";6 "0.008000";7
//    "effective";8 "momentum";9 "0.900000";10 "momentum";11 "as";12 "time";13 "constant";14
//    "237.3";15 "samples";16|]
    {
        Epoch           = int xs.[2]
        LRSample        = float xs.[7]
        Momentum        = float xs.[10]
        MConstSamples   = float xs.[15]
    }

let cntkParse (l:string) =
//    printfn "parsing '%s'"l
    try
        if l.Length > 16 && l.IndexOf("Finished Epoch",0,16) >= 0 then
            parseEndEpoch l |> EE
        elif l.Length > 10 && l.IndexOf("Epoch", 0, 10) >= 0 then 
            parseMinibatch l |> MB
        elif l.Length > 20 && l.IndexOf("Starting Epoch",0,16) >= 0 then
            parseStartEpoch l |> SE
        else
            Unk l
    with ex ->
        printfn "error: %s - in parsing '%s'" ex.Message l
        Unk l

let filterMB = function MB _ -> true | _  -> false
let filterEE = function EE _ -> true | _  -> false
let chooseMB = function MB b -> Some b | _ -> None
let chooseEE = function EE e -> Some e | _ -> None
let chooseSE = function SE e -> Some e | _ -> None
let excludeUnk = function Unk _ -> None | x -> Some x

///filter to use with tail function to reduce processing burden - excludes minibatch updates
let tailFilterWihoutMB (s:string) = s.StartsWith("Finished") || s.StartsWith("Starting Epoch")

///warning: generates too much data for parsing to keep pace in most cases but may work for some models
let tailFilterWithMB (s:string) = tailFilterWihoutMB s || s.StartsWith(" Epoch[")

(*
let mb = "Epoch[ 1 of 100]-Minibatch[18481-18490]: CE = 0.48781250 * 250; Err = 0.18800000 * 250; time = 0.0271s; samplesPerSecond = 9216.3"
let mb2 = " Epoch[83 of 100]-Minibatch[11591-11600, 62.43%]: CE = 0.55243750 * 250; Err = 0.24800000 * 250; time = 0.0344s; samplesPerSecond = 7276.3"
let ee = "Finished Epoch[21 of 100]: [Training] CE = 0.47475340 * 464505; Err = 0.19504419 * 464505; totalSamplesSeen = 9754605; learningRatePerSample = 0.0080000004; epochTime=58.2492s"
cntkParse mb
cntkParse ee
cntkParse mb2
*)

open System.IO
//tail function to read the CNTK Error log file; cancel token to stop
let tail filter (cts:System.Threading.CancellationTokenSource) file fPost =
    let rdr = new StreamReader(new FileStream(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
    let off = ref rdr.BaseStream.Length
    let go = ref true
    let loop = 
        async {
            try
                while true do
                    do! Async.Sleep 100
                    if rdr.BaseStream.Length <> !off then
                        rdr.BaseStream.Seek(!off,SeekOrigin.Begin) |> ignore
                        let mutable l = rdr.ReadLine()
                        while l <> null do
                            if not cts.IsCancellationRequested then
                                if filter l then fPost l
                                l <- rdr.ReadLine()
                        off := rdr.BaseStream.Position
            finally
                    rdr.Close()
                    printfn "closed tail %s" file
            }
    Async.Start(loop,cts.Token)

(* tail usage:
let file = @"C:\cntk\err\hoderr"
let cts = new System.Threading.CancellationTokenSource()
//snippet ref for below: http://fssnip.net/nC
let obs,fPost = Observable.createObservableAgent 100 cts.Token
do tail tailFilterWihoutMB cts file fPost

//cancel reading
cts.Cancel()
*)
module CNTLLogParser
type MiniBatch =
  {Epoch: int;
   Epochs: int;
   MbFrom: int;
   MbTo: int;
   Percent: float;
   CE: float;
   Times: float;
   Err: float;
   Time: TimeSpan;
   SPS: float;}

Full name: CNTLLogParser.MiniBatch
MiniBatch.Epoch: int
Multiple items
val int : value:'T -> int (requires member op_Explicit)

Full name: Microsoft.FSharp.Core.Operators.int

--------------------
type int = int32

Full name: Microsoft.FSharp.Core.int

--------------------
type int<'Measure> = int

Full name: Microsoft.FSharp.Core.int<_>
MiniBatch.Epochs: int
MiniBatch.MbFrom: int
MiniBatch.MbTo: int
MiniBatch.Percent: float
Multiple items
val float : value:'T -> float (requires member op_Explicit)

Full name: Microsoft.FSharp.Core.Operators.float

--------------------
type float = System.Double

Full name: Microsoft.FSharp.Core.float

--------------------
type float<'Measure> = float

Full name: Microsoft.FSharp.Core.float<_>
MiniBatch.CE: float
MiniBatch.Times: float
MiniBatch.Err: float
MiniBatch.Time: System.TimeSpan
namespace System
Multiple items
type TimeSpan =
  struct
    new : ticks:int64 -> TimeSpan + 3 overloads
    member Add : ts:TimeSpan -> TimeSpan
    member CompareTo : value:obj -> int + 1 overload
    member Days : int
    member Duration : unit -> TimeSpan
    member Equals : value:obj -> bool + 1 overload
    member GetHashCode : unit -> int
    member Hours : int
    member Milliseconds : int
    member Minutes : int
    ...
  end

Full name: System.TimeSpan

--------------------
System.TimeSpan()
System.TimeSpan(ticks: int64) : unit
System.TimeSpan(hours: int, minutes: int, seconds: int) : unit
System.TimeSpan(days: int, hours: int, minutes: int, seconds: int) : unit
System.TimeSpan(days: int, hours: int, minutes: int, seconds: int, milliseconds: int) : unit
MiniBatch.SPS: float
type EpochEnd =
  {Epoch: int;
   Mode: string;
   CE: float;
   Times: float;
   Err: float;
   TotalSamples: int;
   LR: float;
   EpochTime: TimeSpan;}

Full name: CNTLLogParser.EpochEnd
EpochEnd.Epoch: int
EpochEnd.Mode: string
Multiple items
val string : value:'T -> string

Full name: Microsoft.FSharp.Core.Operators.string

--------------------
type string = System.String

Full name: Microsoft.FSharp.Core.string
EpochEnd.CE: float
EpochEnd.Times: float
EpochEnd.Err: float
EpochEnd.TotalSamples: int
EpochEnd.LR: float
EpochEnd.EpochTime: System.TimeSpan
type EpochStart =
  {Epoch: int;
   LRSample: float;
   Momentum: float;
   MConstSamples: float;}

Full name: CNTLLogParser.EpochStart
EpochStart.Epoch: int
EpochStart.LRSample: float
EpochStart.Momentum: float
EpochStart.MConstSamples: float
type LogMsg =
  | MB of MiniBatch
  | EE of EpochEnd
  | Unk of string
  | SE of EpochStart

Full name: CNTLLogParser.LogMsg
union case LogMsg.MB: MiniBatch -> LogMsg
union case LogMsg.EE: EpochEnd -> LogMsg
union case LogMsg.Unk: string -> LogMsg
union case LogMsg.SE: EpochStart -> LogMsg
val delims : char []

Full name: CNTLLogParser.delims
val private parseMinibatch : l:string -> MiniBatch

Full name: CNTLLogParser.parseMinibatch
val l : string
val xs : string []
System.String.Split([<System.ParamArray>] separator: char []) : string []
System.String.Split(separator: string [], options: System.StringSplitOptions) : string []
System.String.Split(separator: char [], options: System.StringSplitOptions) : string []
System.String.Split(separator: char [], count: int) : string []
System.String.Split(separator: string [], count: int, options: System.StringSplitOptions) : string []
System.String.Split(separator: char [], count: int, options: System.StringSplitOptions) : string []
type StringSplitOptions =
  | None = 0
  | RemoveEmptyEntries = 1

Full name: System.StringSplitOptions
field System.StringSplitOptions.RemoveEmptyEntries = 1
System.TimeSpan.FromSeconds(value: float) : System.TimeSpan
val private parseEndEpoch : l:string -> EpochEnd

Full name: CNTLLogParser.parseEndEpoch
val private parseStartEpoch : l:string -> EpochStart

Full name: CNTLLogParser.parseStartEpoch
val cntkParse : l:string -> LogMsg

Full name: CNTLLogParser.cntkParse
property System.String.Length: int
System.String.IndexOf(value: string) : int
System.String.IndexOf(value: char) : int
System.String.IndexOf(value: string, comparisonType: System.StringComparison) : int
System.String.IndexOf(value: string, startIndex: int) : int
System.String.IndexOf(value: char, startIndex: int) : int
System.String.IndexOf(value: string, startIndex: int, comparisonType: System.StringComparison) : int
System.String.IndexOf(value: string, startIndex: int, count: int) : int
System.String.IndexOf(value: char, startIndex: int, count: int) : int
System.String.IndexOf(value: string, startIndex: int, count: int, comparisonType: System.StringComparison) : int
val ex : exn
val printfn : format:Printf.TextWriterFormat<'T> -> 'T

Full name: Microsoft.FSharp.Core.ExtraTopLevelOperators.printfn
property System.Exception.Message: string
val filterMB : _arg1:LogMsg -> bool

Full name: CNTLLogParser.filterMB
val filterEE : _arg1:LogMsg -> bool

Full name: CNTLLogParser.filterEE
val chooseMB : _arg1:LogMsg -> MiniBatch option

Full name: CNTLLogParser.chooseMB
val b : MiniBatch
union case Option.Some: Value: 'T -> Option<'T>
union case Option.None: Option<'T>
val chooseEE : _arg1:LogMsg -> EpochEnd option

Full name: CNTLLogParser.chooseEE
val e : EpochEnd
val chooseSE : _arg1:LogMsg -> EpochStart option

Full name: CNTLLogParser.chooseSE
val e : EpochStart
val excludeUnk : _arg1:LogMsg -> LogMsg option

Full name: CNTLLogParser.excludeUnk
val x : LogMsg
val tailFilterWihoutMB : s:string -> bool

Full name: CNTLLogParser.tailFilterWihoutMB


filter to use with tail function to reduce processing burden - excludes minibatch updates
val s : string
System.String.StartsWith(value: string) : bool
System.String.StartsWith(value: string, comparisonType: System.StringComparison) : bool
System.String.StartsWith(value: string, ignoreCase: bool, culture: System.Globalization.CultureInfo) : bool
val tailFilterWithMB : s:string -> bool

Full name: CNTLLogParser.tailFilterWithMB


warning: generates too much data for parsing to keep pace in most cases but may work for some models
namespace System.IO
val tail : filter:(string -> bool) -> cts:System.Threading.CancellationTokenSource -> file:string -> fPost:(string -> unit) -> unit

Full name: CNTLLogParser.tail
val filter : (string -> bool)
val cts : System.Threading.CancellationTokenSource
namespace System.Threading
Multiple items
type CancellationTokenSource =
  new : unit -> CancellationTokenSource
  member Cancel : unit -> unit + 1 overload
  member Dispose : unit -> unit
  member IsCancellationRequested : bool
  member Token : CancellationToken
  static member CreateLinkedTokenSource : [<ParamArray>] tokens:CancellationToken[] -> CancellationTokenSource + 1 overload

Full name: System.Threading.CancellationTokenSource

--------------------
System.Threading.CancellationTokenSource() : unit
val file : string
val fPost : (string -> unit)
val rdr : StreamReader
Multiple items
type StreamReader =
  inherit TextReader
  new : stream:Stream -> StreamReader + 9 overloads
  member BaseStream : Stream
  member Close : unit -> unit
  member CurrentEncoding : Encoding
  member DiscardBufferedData : unit -> unit
  member EndOfStream : bool
  member Peek : unit -> int
  member Read : unit -> int + 1 overload
  member ReadLine : unit -> string
  member ReadToEnd : unit -> string
  ...

Full name: System.IO.StreamReader

--------------------
StreamReader(stream: Stream) : unit
StreamReader(path: string) : unit
StreamReader(stream: Stream, detectEncodingFromByteOrderMarks: bool) : unit
StreamReader(stream: Stream, encoding: System.Text.Encoding) : unit
StreamReader(path: string, detectEncodingFromByteOrderMarks: bool) : unit
StreamReader(path: string, encoding: System.Text.Encoding) : unit
StreamReader(stream: Stream, encoding: System.Text.Encoding, detectEncodingFromByteOrderMarks: bool) : unit
StreamReader(path: string, encoding: System.Text.Encoding, detectEncodingFromByteOrderMarks: bool) : unit
StreamReader(stream: Stream, encoding: System.Text.Encoding, detectEncodingFromByteOrderMarks: bool, bufferSize: int) : unit
StreamReader(path: string, encoding: System.Text.Encoding, detectEncodingFromByteOrderMarks: bool, bufferSize: int) : unit
Multiple items
type FileStream =
  inherit Stream
  new : path:string * mode:FileMode -> FileStream + 14 overloads
  member BeginRead : array:byte[] * offset:int * numBytes:int * userCallback:AsyncCallback * stateObject:obj -> IAsyncResult
  member BeginWrite : array:byte[] * offset:int * numBytes:int * userCallback:AsyncCallback * stateObject:obj -> IAsyncResult
  member CanRead : bool
  member CanSeek : bool
  member CanWrite : bool
  member EndRead : asyncResult:IAsyncResult -> int
  member EndWrite : asyncResult:IAsyncResult -> unit
  member Flush : unit -> unit + 1 overload
  member GetAccessControl : unit -> FileSecurity
  ...

Full name: System.IO.FileStream

--------------------
FileStream(path: string, mode: FileMode) : unit
   (+0 other overloads)
FileStream(handle: Win32.SafeHandles.SafeFileHandle, access: FileAccess) : unit
   (+0 other overloads)
FileStream(path: string, mode: FileMode, access: FileAccess) : unit
   (+0 other overloads)
FileStream(handle: Win32.SafeHandles.SafeFileHandle, access: FileAccess, bufferSize: int) : unit
   (+0 other overloads)
FileStream(path: string, mode: FileMode, access: FileAccess, share: FileShare) : unit
   (+0 other overloads)
FileStream(handle: Win32.SafeHandles.SafeFileHandle, access: FileAccess, bufferSize: int, isAsync: bool) : unit
   (+0 other overloads)
FileStream(path: string, mode: FileMode, access: FileAccess, share: FileShare, bufferSize: int) : unit
   (+0 other overloads)
FileStream(path: string, mode: FileMode, access: FileAccess, share: FileShare, bufferSize: int, options: FileOptions) : unit
   (+0 other overloads)
FileStream(path: string, mode: FileMode, access: FileAccess, share: FileShare, bufferSize: int, useAsync: bool) : unit
   (+0 other overloads)
FileStream(path: string, mode: FileMode, rights: System.Security.AccessControl.FileSystemRights, share: FileShare, bufferSize: int, options: FileOptions) : unit
   (+0 other overloads)
type FileMode =
  | CreateNew = 1
  | Create = 2
  | Open = 3
  | OpenOrCreate = 4
  | Truncate = 5
  | Append = 6

Full name: System.IO.FileMode
field FileMode.Open = 3
type FileAccess =
  | Read = 1
  | Write = 2
  | ReadWrite = 3

Full name: System.IO.FileAccess
field FileAccess.Read = 1
type FileShare =
  | None = 0
  | Read = 1
  | Write = 2
  | ReadWrite = 3
  | Delete = 4
  | Inheritable = 16

Full name: System.IO.FileShare
field FileShare.ReadWrite = 3
val off : int64 ref
Multiple items
val ref : value:'T -> 'T ref

Full name: Microsoft.FSharp.Core.Operators.ref

--------------------
type 'T ref = Ref<'T>

Full name: Microsoft.FSharp.Core.ref<_>
property StreamReader.BaseStream: Stream
property Stream.Length: int64
val go : bool ref
val loop : Async<unit>
val async : AsyncBuilder

Full name: Microsoft.FSharp.Core.ExtraTopLevelOperators.async
Multiple items
type Async
static member AsBeginEnd : computation:('Arg -> Async<'T>) -> ('Arg * AsyncCallback * obj -> IAsyncResult) * (IAsyncResult -> 'T) * (IAsyncResult -> unit)
static member AwaitEvent : event:IEvent<'Del,'T> * ?cancelAction:(unit -> unit) -> Async<'T> (requires delegate and 'Del :> Delegate)
static member AwaitIAsyncResult : iar:IAsyncResult * ?millisecondsTimeout:int -> Async<bool>
static member AwaitTask : task:Task -> Async<unit>
static member AwaitTask : task:Task<'T> -> Async<'T>
static member AwaitWaitHandle : waitHandle:WaitHandle * ?millisecondsTimeout:int -> Async<bool>
static member CancelDefaultToken : unit -> unit
static member Catch : computation:Async<'T> -> Async<Choice<'T,exn>>
static member FromBeginEnd : beginAction:(AsyncCallback * obj -> IAsyncResult) * endAction:(IAsyncResult -> 'T) * ?cancelAction:(unit -> unit) -> Async<'T>
static member FromBeginEnd : arg:'Arg1 * beginAction:('Arg1 * AsyncCallback * obj -> IAsyncResult) * endAction:(IAsyncResult -> 'T) * ?cancelAction:(unit -> unit) -> Async<'T>
static member FromBeginEnd : arg1:'Arg1 * arg2:'Arg2 * beginAction:('Arg1 * 'Arg2 * AsyncCallback * obj -> IAsyncResult) * endAction:(IAsyncResult -> 'T) * ?cancelAction:(unit -> unit) -> Async<'T>
static member FromBeginEnd : arg1:'Arg1 * arg2:'Arg2 * arg3:'Arg3 * beginAction:('Arg1 * 'Arg2 * 'Arg3 * AsyncCallback * obj -> IAsyncResult) * endAction:(IAsyncResult -> 'T) * ?cancelAction:(unit -> unit) -> Async<'T>
static member FromContinuations : callback:(('T -> unit) * (exn -> unit) * (OperationCanceledException -> unit) -> unit) -> Async<'T>
static member Ignore : computation:Async<'T> -> Async<unit>
static member OnCancel : interruption:(unit -> unit) -> Async<IDisposable>
static member Parallel : computations:seq<Async<'T>> -> Async<'T []>
static member RunSynchronously : computation:Async<'T> * ?timeout:int * ?cancellationToken:CancellationToken -> 'T
static member Sleep : millisecondsDueTime:int -> Async<unit>
static member Start : computation:Async<unit> * ?cancellationToken:CancellationToken -> unit
static member StartAsTask : computation:Async<'T> * ?taskCreationOptions:TaskCreationOptions * ?cancellationToken:CancellationToken -> Task<'T>
static member StartChild : computation:Async<'T> * ?millisecondsTimeout:int -> Async<Async<'T>>
static member StartChildAsTask : computation:Async<'T> * ?taskCreationOptions:TaskCreationOptions -> Async<Task<'T>>
static member StartImmediate : computation:Async<unit> * ?cancellationToken:CancellationToken -> unit
static member StartWithContinuations : computation:Async<'T> * continuation:('T -> unit) * exceptionContinuation:(exn -> unit) * cancellationContinuation:(OperationCanceledException -> unit) * ?cancellationToken:CancellationToken -> unit
static member SwitchToContext : syncContext:SynchronizationContext -> Async<unit>
static member SwitchToNewThread : unit -> Async<unit>
static member SwitchToThreadPool : unit -> Async<unit>
static member TryCancelled : computation:Async<'T> * compensation:(OperationCanceledException -> unit) -> Async<'T>
static member CancellationToken : Async<CancellationToken>
static member DefaultCancellationToken : CancellationToken

Full name: Microsoft.FSharp.Control.Async

--------------------
type Async<'T>

Full name: Microsoft.FSharp.Control.Async<_>
static member Async.Sleep : millisecondsDueTime:int -> Async<unit>
Stream.Seek(offset: int64, origin: SeekOrigin) : int64
type SeekOrigin =
  | Begin = 0
  | Current = 1
  | End = 2

Full name: System.IO.SeekOrigin
field SeekOrigin.Begin = 0
val ignore : value:'T -> unit

Full name: Microsoft.FSharp.Core.Operators.ignore
val mutable l : string
StreamReader.ReadLine() : string
val not : value:bool -> bool

Full name: Microsoft.FSharp.Core.Operators.not
property System.Threading.CancellationTokenSource.IsCancellationRequested: bool
property Stream.Position: int64
StreamReader.Close() : unit
static member Async.Start : computation:Async<unit> * ?cancellationToken:System.Threading.CancellationToken -> unit
property System.Threading.CancellationTokenSource.Token: System.Threading.CancellationToken

More information

Link:http://fssnip.net/7Rm
Posted:9 months ago
Author:Faisal Waris
Tags: cntk , tail file