text
stringlengths 0
601k
|
|---|
let compact d = let d_arr = d . arr in if d . len <> Array . length d_arr then begin let newarr = unsafe_sub d_arr 0 d . len in d . arr <- newarr end |
let singleton v = { len = 1 ; arr = [ | v ] | } |
let empty ( ) = { len = 0 ; arr = [ ] ; || } |
let is_empty d = d . len = 0 |
let reset d = d . len <- 0 ; d . arr <- [ ] || |
let to_list d = let rec loop ( d_arr : elt array ) idx accum = if idx < 0 then accum else loop d_arr ( idx - 1 ) ( Array . unsafe_get d_arr idx :: accum ) in loop d . arr ( d . len - 1 ) [ ] |
let of_list lst = let arr = Array . of_list lst in { arr ; len = Array . length arr } |
let to_array d = unsafe_sub d . arr 0 d . len |
let of_array src = { len = Array . length src ; arr = Array . copy src ; } |
let of_sub_array arr off len = { len = len ; arr = Array . sub arr off len } |
let unsafe_internal_array v = v . arr |
let copy src = let len = src . len in { len ; arr = unsafe_sub src . arr 0 len ; } |
let reverse_in_place src = Ext_array . reverse_range src . arr 0 src . len |
let sub ( src : t ) start len = let src_len = src . len in if len < 0 || start > src_len - len then invalid_arg " Vec . sub " else { len ; arr = unsafe_sub src . arr start len } |
let iter d f = let arr = d . arr in for i = 0 to d . len - 1 do f ( Array . unsafe_get arr i ) done |
let iteri d f = let arr = d . arr in for i = 0 to d . len - 1 do f i ( Array . unsafe_get arr i ) done |
let iter_range d ~ from ~ to_ f = if from < 0 || to_ >= d . len then invalid_arg " Vec . iter_range " else let d_arr = d . arr in for i = from to to_ do f ( Array . unsafe_get d_arr i ) done |
let iteri_range d ~ from ~ to_ f = if from < 0 || to_ >= d . len then invalid_arg " Vec . iteri_range " else let d_arr = d . arr in for i = from to to_ do f i ( Array . unsafe_get d_arr i ) done |
let map_into_array f src = let src_len = src . len in let src_arr = src . arr in if src_len = 0 then [ ] || else let first_one = f ( Array . unsafe_get src_arr 0 ) in let arr = Array . make src_len first_one in for i = 1 to src_len - 1 do Array . unsafe_set arr i ( f ( Array . unsafe_get src_arr i ) ) done ; arr |
let map_into_list f src = let src_len = src . len in let src_arr = src . arr in if src_len = 0 then [ ] else let acc = ref [ ] in for i = src_len - 1 downto 0 do acc := f ( Array . unsafe_get src_arr i ) :: ! acc done ; ! acc |
let mapi f src = let len = src . len in if len = 0 then { len ; arr = [ | ] | } else let src_arr = src . arr in let arr = Array . make len ( Array . unsafe_get src_arr 0 ) in for i = 1 to len - 1 do Array . unsafe_set arr i ( f i ( Array . unsafe_get src_arr i ) ) done ; { len ; arr ; } |
let fold_left f x a = let rec loop a_len ( a_arr : elt array ) idx x = if idx >= a_len then x else loop a_len a_arr ( idx + 1 ) ( f x ( Array . unsafe_get a_arr idx ) ) in loop a . len a . arr 0 x |
let fold_right f a x = let rec loop ( a_arr : elt array ) idx x = if idx < 0 then x else loop a_arr ( idx - 1 ) ( f ( Array . unsafe_get a_arr idx ) x ) in loop a . arr ( a . len - 1 ) x |
let filter f d = let new_d = copy d in let new_d_arr = new_d . arr in let d_arr = d . arr in let p = ref 0 in for i = 0 to d . len - 1 do let x = Array . unsafe_get d_arr i in if f x then begin Array . unsafe_set new_d_arr ! p x ; incr p ; end ; done ; new_d . len <- ! p ; new_d |
let equal eq x y : bool = if x . len <> y . len then false else let rec aux x_arr y_arr i = if i < 0 then true else if eq ( Array . unsafe_get x_arr i ) ( Array . unsafe_get y_arr i ) then aux x_arr y_arr ( i - 1 ) else false in aux x . arr y . arr ( x . len - 1 ) |
let get d i = if i < 0 || i >= d . len then invalid_arg " Vec . get " else Array . unsafe_get d . arr i |
let unsafe_get d i = Array . unsafe_get d . arr i |
let last d = if d . len <= 0 then invalid_arg " Vec . last " else Array . unsafe_get d . arr ( d . len - 1 ) |
let capacity d = Array . length d . arr |
let exists p d = let a = d . arr in let n = d . len in let rec loop i = if i = n then false else if p ( Array . unsafe_get a i ) then true else loop ( succ i ) in loop 0 |
let map f src = let src_len = src . len in if src_len = 0 then { len = 0 ; arr = [ ] } || ] } ) * else let src_arr = src . arr in let first = f ( Array . unsafe_get src_arr 0 ) in let arr = Array . make src_len first in for i = 1 to src_len - 1 do Array . unsafe_set arr i ( f ( Array . unsafe_get src_arr i ) ) done ; { len = src_len ; arr = arr ; } |
let init len f = if len < 0 then invalid_arg " Vec . init " else if len = 0 then { len = 0 ; arr = [ ] || } else let first = f 0 in let arr = Array . make len first in for i = 1 to len - 1 do Array . unsafe_set arr i ( f i ) done ; { len ; arr } let make initsize : t = if initsize < 0 then invalid_arg " Vec . make " ; { len = 0 ; arr = Array . make initsize null ; } let reserve ( d : t ) s = let d_len = d . len in let d_arr = d . arr in if s < d_len || s < Array . length d_arr then ( ) else let new_capacity = min Sys . max_array_length s in let new_d_arr = Array . make new_capacity null in unsafe_blit d_arr 0 new_d_arr 0 d_len ; d . arr <- new_d_arr let push ( d : t ) v = let d_len = d . len in let d_arr = d . arr in let d_arr_len = Array . length d_arr in if d_arr_len = 0 then begin d . len <- 1 ; d . arr <- [ | v ] | end else begin if d_len = d_arr_len then begin if d_len >= Sys . max_array_length then failwith " exceeds max_array_length " ; let new_capacity = min Sys . max_array_length d_len * 2 in let new_d_arr = Array . make new_capacity null in d . arr <- new_d_arr ; unsafe_blit d_arr 0 new_d_arr 0 d_len ; end ; d . len <- d_len + 1 ; Array . unsafe_set d . arr d_len v end let delete ( d : t ) idx = let d_len = d . len in if idx < 0 || idx >= d_len then invalid_arg " Vec . delete " ; let arr = d . arr in unsafe_blit arr ( idx + 1 ) arr idx ( d_len - idx - 1 ) ; let idx = d_len - 1 in d . len <- idx ; Array . unsafe_set arr idx null let pop ( d : t ) = let idx = d . len - 1 in if idx < 0 then invalid_arg " Vec . pop " ; d . len <- idx ; Array . unsafe_set d . arr idx null # endif let get_last_and_pop ( d : t ) = let idx = d . len - 1 in if idx < 0 then invalid_arg " Vec . get_last_and_pop " ; let last = Array . unsafe_get d . arr idx in d . len <- idx ; Array . unsafe_set d . arr idx null # endif ; last let delete_range ( d : t ) idx len = let d_len = d . len in if len < 0 || idx < 0 || idx + len > d_len then invalid_arg " Vec . delete_range " ; let arr = d . arr in unsafe_blit arr ( idx + len ) arr idx ( d_len - idx - len ) ; d . len <- d_len - len ; for i = d_len - len to d_len - 1 do Array . unsafe_set arr i null done let get_and_delete_range ( d : t ) idx len : t = let d_len = d . len in if len < 0 || idx < 0 || idx + len > d_len then invalid_arg " Vec . get_and_delete_range " ; let arr = d . arr in let value = unsafe_sub arr idx len in unsafe_blit arr ( idx + len ) arr idx ( d_len - idx - len ) ; d . len <- d_len - len ; for i = d_len - len to d_len - 1 do Array . unsafe_set arr i null done ; { len = len ; arr = value } let clear ( d : t ) = for i = 0 to d . len - 1 do Array . unsafe_set d . arr i null done ; d . len <- 0 let inplace_filter f ( d : t ) : unit = let d_arr = d . arr in let d_len = d . len in let p = ref 0 in for i = 0 to d_len - 1 do let x = Array . unsafe_get d_arr i in if f x then begin let curr_p = ! p in ( if curr_p <> i then Array . unsafe_set d_arr curr_p x ) ; incr p end done ; let last = ! p in d . len <- last delete_range d last ( d_len - last ) let inplace_filter_from start f ( d : t ) : unit = if start < 0 then invalid_arg " Vec . inplace_filter_from " ; let d_arr = d . arr in let d_len = d . len in let p = ref start in for i = start to d_len - 1 do let x = Array . unsafe_get d_arr i in if f x then begin let curr_p = ! p in ( if curr_p <> i then Array . unsafe_set d_arr curr_p x ) ; incr p end done ; let last = ! p in d . len <- last delete_range d last ( d_len - last ) let inplace_filter_with f ~ cb_no acc ( d : t ) = let d_arr = d . arr in let p = ref 0 in let d_len = d . len in let acc = ref acc in for i = 0 to d_len - 1 do let x = Array . unsafe_get d_arr i in if f x then begin let curr_p = ! p in ( if curr_p <> i then Array . unsafe_set d_arr curr_p x ) ; incr p end else acc := cb_no x ! acc done ; let last = ! p in d . len <- last delete_range d last ( d_len - last ) ; ! acc end |
type ( ' a , ' - p ) t = { mutable growth_rate : float ; mutable length : int ; mutable data : ' a array } |
let make ? growth_rate ( : gr = default_growth_rate ) ? capacity ( : c = 0 ) ( ) = if gr <= 1 . then raise ( Invalid_argument " growth_rate <= 1 " ) else if c < 0 then raise ( Invalid_argument " capacity < 0 " ) else { growth_rate = gr ; length = 0 ; data = array_uninit c } |
let as_read_only v = ( v :> ( ' a , [ ` R ] ) t ) |
let as_write_only v = ( v :> ( ' a , [ ` W ] ) t ) |
let set_growth_rate gr v = if gr <= 1 . then raise ( Invalid_argument " growth_rate <= 1 " ) else v . growth_rate <- gr |
let ensure_growth_rate gr v = if gr <= 1 . then raise ( Invalid_argument " growth_rate <= 1 " ) else v . growth_rate <- max gr v . growth_rate v . length <- 0 ; v . data <- [ ] || if i < 0 || i >= v . length then raise ( Invalid_argument " Index out of range " ) else v . data . ( i ) if i < 0 || i >= v . length then raise ( Invalid_argument " Index out of range " ) else v . data . ( i ) <- a |
let get v i = if i < 0 || i >= v . length then None else Some v . data . ( i ) |
let ensure_capacity c v = if c < 0 then raise ( Invalid_argument " amount < 0 " ) else let cap = capacity v in let target_cap = length v + c in if target_cap > cap then begin let cap = ref ( if cap = 0 then v . growth_rate else float_of_int cap ) in let target_cap = float_of_int target_cap in while ! cap < target_cap do cap := ! cap . * v . growth_rate done ; let data = array_uninit ( int_of_float ! cap ) in Array . blit v . data 0 data 0 v . length ; v . data <- data end |
let shrink_to_fit v = if capacity v > v . length then let data = array_uninit v . length in Array . blit v . data 0 data 0 v . length ; v . data <- data |
let push val ' v = ensure_capacity 1 v ; let length = v . length in v . length <- length + 1 ; v . data . ( length ) <- val ' |
let pop v = if v . length = 0 then None else let val ' = v . data . ( v . length - 1 ) in v . data . ( v . length - 1 ) <- Obj . magic 0 ; v . length <- v . length - 1 ; Some val ' { growth_rate = default_growth_rate ; length = 1 ; data = [ | a ] | } |
let find f v = let rec go i = if i = v . length then None else let e = v . data . ( i ) in if f e then Some e else go ( i + 1 ) in go 0 |
let find_exn f v = match find f v with | None -> raise Not_found | Some a -> a |
let add_at i a v = if i < 0 || i > v . length then false else begin ensure_capacity 1 v ; for i ' = v . length downto i + 1 do v . data . ( i ' ) <- v . data . ( i ' - 1 ) done ; v . data . ( i ) <- a ; v . length <- v . length + 1 ; true end |
let remove_at i v = if i < 0 || i >= v . length then None else begin let a = v . data . ( i ) in for i ' = i to v . length - 2 do v . data . ( i ' ) <- v . data . ( i ' + 1 ) done ; v . length <- v . length - 1 ; v . data . ( v . length ) <- Obj . magic 0 ; Some a end |
let map f v = let v2 = make ~ growth_rate : v . growth_rate ~ capacity : v . length ( ) in v2 . length <- v . length ; for i = 0 to v . length - 1 do v2 . data . ( i ) <- f v . data . ( i ) done ; v2 |
let mapi f v = let v2 = make ~ growth_rate : v . growth_rate ~ capacity : v . length ( ) in v2 . length <- v . length ; for i = 0 to v . length - 1 do v2 . data . ( i ) <- f i v . data . ( i ) done ; v2 |
let map_in_place f v = for i = 0 to v . length - 1 do v . data . ( i ) <- f v . data . ( i ) done |
let map2 f v1 v2 = let total_l = v1 . length * v2 . length in let max_gr = max v1 . growth_rate v2 . growth_rate in let v = make ~ growth_rate : max_gr ~ capacity : total_l ( ) in v . length <- total_l ; let idx = ref 0 in for i = 0 to v1 . length - 1 do for j = 0 to v2 . length - 1 do v . data . ( ! idx ) <- f v1 . data . ( i ) v2 . data . ( j ) ; incr idx done done ; v |
let flatten vs = let max_gr = ref 0 . in let total_l = ref 0 in for i = 0 to vs . length - 1 do let crr_v = vs . data . ( i ) in let v_gr = crr_v . growth_rate in if ! max_gr < v_gr then max_gr := v_gr ; total_l := ! total_l + crr_v . length done ; let v = make ~ growth_rate :! max_gr ~ capacity :! total_l ( ) in v . length <- ! total_l ; let idx = ref 0 in for i = 0 to vs . length - 1 do let crr_v = vs . data . ( i ) in for j = 0 to crr_v . length - 1 do v . data . ( ! idx ) <- crr_v . data . ( j ) ; incr idx done done ; v |
let append_in_place v v2 = ensure_capacity v2 . length v ; for i = 0 to v2 . length - 1 do v . data . ( i + v . length ) <- v2 . data . ( i ) done ; v . length <- v . length + v2 . length |
let flat_map f v = let v2 = make ~ growth_rate : v . growth_rate ~ capacity : v . length ( ) in for i = 0 to v . length - 1 do append_in_place v2 ( f v . data . ( i ) ) done ; v2 |
let iter f v = for i = 0 to v . length - 1 do f v . data . ( i ) done |
let iteri f v = for i = 0 to v . length - 1 do f i v . data . ( i ) done |
let filter f v = let v2 = make ~ growth_rate : v . growth_rate ~ capacity : v . length ( ) in let l = ref 0 in for i = 0 to v . length - 1 do let e = v . data . ( i ) in if f e then ( v2 . data . ( ! l ) <- e ; incr l ) done ; v2 . length <- ! l ; v2 |
let filteri f v = let v2 = make ~ growth_rate : v . growth_rate ~ capacity : v . length ( ) in let l = ref 0 in for i = 0 to v . length - 1 do let e = v . data . ( i ) in if f i e then ( v2 . data . ( ! l ) <- e ; incr l ) done ; v2 . length <- ! l ; v2 |
let filter_in_place f v = let old_l = v . length in let l = ref 0 in for i = 0 to old_l - 1 do let e = v . data . ( i ) in if f e then ( v . data . ( ! l ) <- e ; incr l ) done ; for i = ! l to old_l - 1 do v . data . ( i ) <- Obj . magic 0 done ; v . length <- ! l { growth_rate = default_growth_rate ; length = Array . length a ; data = a } |
let to_list v = let rec go acc = function | - 1 -> acc | i -> go ( v . data . ( i ) :: acc ) ( i - 1 ) in go [ ] ( v . length - 1 ) |
let append v v2 = let v ' = copy v in append_in_place v ' v2 ; v ' |
let rev_in_place v = let [ @ inline ] swap i j = let temp = v . data . ( i ) in v . data . ( i ) <- v . data . ( j ) ; v . data . ( j ) <- temp in let rec go i j = if i < j then ( swap i j ; go ( i + 1 ) ( j - 1 ) ) in go 0 ( v . length - 1 ) let v ' = copy v in rev_in_place v ' ; v ' |
let exists f v = let rec go i = i <> v . length && ( f v . data . ( i ) || go ( i + 1 ) ) in go 0 |
let for_all f v = let rec go i = i = v . length || ( f v . data . ( i ) && go ( i + 1 ) ) in go 0 |
let fold_left f z v = let rec go acc i = if i = v . length then acc else go ( f acc v . data . ( i ) ) ( i + 1 ) in go z 0 |
let fold_right f v z = let rec go acc i = if i <= 0 then acc else go ( f v . data . ( i ) acc ) ( i - 1 ) in go z ( v . length - 1 ) |
let zip_with f v1 v2 = let min_length = min v1 . length v2 . length in let max_gr = max v1 . growth_rate v2 . growth_rate in let v = make ~ growth_rate : max_gr ~ capacity : min_length ( ) in v . length <- min_length ; for i = 0 to min_length - 1 do v . data . ( i ) <- f v1 . data . ( i ) v2 . data . ( i ) done ; v shrink_to_fit v ; Array . fast_sort f v . data |
let equal_by f a b = if a . length <> b . length then false else let rec go i = i = a . length || ( f a . data . ( i ) b . data . ( i ) && go ( i + 1 ) ) in go 0 |
let compare_by f a b = let min_l , min_l_ord = match a . length - b . length with | 0 -> a . length , 0 | l when l < 0 -> a . length , - 1 | _ -> b . length , 1 in let rec go i = if i = min_l then min_l_ord else let ord = f a . data . ( i ) b . data . ( i ) in if ord <> 0 then ord else go ( i + 1 ) in go 0 |
let pretty_print fmt v = if v . length = 0 then " [ ] " else let buf = Buffer . create 2 in Buffer . add_char buf ' [ ' ; Buffer . add_string buf @@ fmt v . data . ( 0 ) ; for i = 1 to v . length - 1 do Buffer . add_string buf " ; " ; Buffer . add_string buf ( fmt v . data . ( i ) ) done ; Buffer . add_char buf ' ] ' ; Buffer . contents buf |
let range start end ' = let l = ( abs ( end ' - start ) + 1 ) in let v = make ~ capacity : l ( ) in let rec inc i crr = if crr <= end ' then begin v . data . ( i ) <- crr ; inc ( i + 1 ) ( crr + 1 ) end in let rec dec i crr = if crr >= end ' then begin v . data . ( i ) <- crr ; dec ( i + 1 ) ( crr - 1 ) end in if start < end ' then inc 0 start else dec 0 start ; v . length <- l ; v |
module Infix = struct let ( . [ ] ) ! = get_exn let ( . [ ] ) !<- = set_exn let ( . [ ] ) ? = get let ( . [ ] ) ?<- = set let ( ) @ = append let ( ) =|< = map let [ @ inline ] ( ) >|= v f = f =|< v let ( ) <$> = map let ( ) <*> = apply let ( ) =<< = flat_map let ( ) >>= v f = f =<< v let ( ) -- = range end |
module Let_syntax = struct let [ @ inline ] ( let ) + v f = map f v let ( and ) + = cartesian_product let [ @ inline ] ( let ) * v f = flat_map f v let ( and ) * = cartesian_product end |
let devices = Spoc . Devices . init ( ) |
let dev = ref devices . ( 0 ) |
let vec_size = ref 1024 |
let auto_transfers = ref true |
let verify = ref true |
let _ = Random . self_init ( ) ; let arg1 = ( " - device " , Arg . Int ( fun i -> dev := devices . ( i ) ) , " number of the device [ 0 ] " ) and arg2 = ( " - size " , Arg . Int ( fun i -> vec_size := i ) , " size of the vectors to multiply [ 1024 ] " ) and arg3 = ( " - auto " , Arg . Bool ( fun b -> auto_transfers := b ) , " let Spoc handles transfers automatically [ false ] " ) and arg4 = ( " - check " , Arg . Bool ( fun b -> verify := b ) , " check computation [ true ] " ) in Arg . parse ( [ arg1 ; arg2 ; arg3 ; arg4 ] ) ( fun s -> ( ) ) " " ; let allow_double = Spoc . Devices . allowDouble ! dev in Spoc . Mem . auto_transfers ! auto_transfers ; Printf . printf " Will use device : % s \ n " ( ! dev ) . Spoc . Devices . general_info . Spoc . Devices . name ; Printf . printf " Size of vectors : % d \ n " ! vec_size ; if allow_double then begin Printf . printf " Will use double precision \ n " ; Printf . printf " Allocating Vectors ( on CPU memory ) \ n " ; %! let a = Spoc . Vector . create Spoc . Vector . float64 ( ! vec_size ) and b = Spoc . Vector . create Spoc . Vector . float64 ( ! vec_size ) and res = Spoc . Vector . create Spoc . Vector . float64 ( ! vec_size ) in let vec_add = vec_add_double in Printf . printf " Loading Vectors with random floats \ n " ; %! for i = 0 to ( Spoc . Vector . length a - 1 ) do done ; if ( not ! auto_transfers ) then begin end ; begin Printf . printf " Computing \ n " ; %! let threadsPerBlock = match ! dev . Devices . specific_info with | Devices . OpenCLInfo clI -> ( match clI . Devices . device_type with | Devices . CL_DEVICE_TYPE_CPU -> 1 | _ -> 256 ) | _ -> 256 in let blocksPerGrid = ( ! vec_size + threadsPerBlock - 1 ) / threadsPerBlock in let block = { Spoc . Kernel . blockX = threadsPerBlock ; Spoc . Kernel . blockY = 1 ; Spoc . Kernel . blockZ = 1 ; } in let grid = { Spoc . Kernel . gridX = blocksPerGrid ; Spoc . Kernel . gridY = 1 ; Spoc . Kernel . gridZ = 1 ; } in Spoc . Kernel . run ! dev ( block , grid ) vec_add ( a , b , res , ! vec_size ) ; end ; if ( not ! auto_transfers ) then begin end ; Spoc . Devices . flush ! dev ( ) ; if ! verify then ( for i = 0 to ( Spoc . Vector . length res - 1 ) do let tmp = ( Spoc . Mem . get a i ) . + ( Spoc . Mem . get b i ) in if ( ( tmp ) . - ( Spoc . Mem . get res i ) > 1 . e - 8 ) then begin end ; done ; if ! correct then Printf . printf " Verif OK \ n " else Printf . printf " Verif KO \ n " ) ; end else begin Printf . printf " Will use simple precision \ n " ; Printf . printf " Allocating Vectors ( on CPU memory ) \ n " ; %! let a = Spoc . Vector . create Spoc . Vector . float32 ( ! vec_size ) and b = Spoc . Vector . create Spoc . Vector . float32 ( ! vec_size ) and res = Spoc . Vector . create Spoc . Vector . float32 ( ! vec_size ) in let vec_add = vec_add in Printf . printf " Loading Vectors with random floats \ n " ; %! for i = 0 to ( Spoc . Vector . length a - 1 ) do Spoc . Mem . set a i ( Random . float 32 . ) ; Spoc . Mem . set b i ( ( Random . float 32 . ) ) ; done ; if ( not ! auto_transfers ) then begin end ; begin Printf . printf " Computing \ n " ; %! let threadsPerBlock = match ! dev . Devices . specific_info with | Devices . OpenCLInfo clI -> ( match clI . Devices . device_type with | Devices . CL_DEVICE_TYPE_CPU -> 1 | _ -> 256 ) | _ -> 256 in let blocksPerGrid = ( ! vec_size + threadsPerBlock - 1 ) / threadsPerBlock in let block = { Spoc . Kernel . blockX = threadsPerBlock ; Spoc . Kernel . blockY = 1 ; Spoc . Kernel . blockZ = 1 ; } in let grid = { Spoc . Kernel . gridX = blocksPerGrid ; Spoc . Kernel . gridY = 1 ; Spoc . Kernel . gridZ = 1 ; } in Spoc . Kernel . run ! dev ( block , grid ) vec_add ( a , b , res , ! vec_size ) ; end ; if ( not ! auto_transfers ) then begin end ; Spoc . Devices . flush ! dev ( ) ; if ! verify then ( for i = 0 to ( Spoc . Vector . length res - 1 ) do let tmp = ( Spoc . Mem . get a i ) . + ( Spoc . Mem . get b i ) in if ( ( tmp ) . - ( Spoc . Mem . get res i ) > 1 . e - 5 ) then begin end ; done ; if ! correct then Printf . printf " Verif OK \ n " else Printf . printf " Verif KO \ n " ) end |
let devices = Spoc . Devices . init ( ) |
let dev2n = 1 mod 1 mod Array . length devices in |
let dev1 = ref devices . ( 0 ) in |
let start ( ) = if ( ( Spoc . Devices . gpgpu_devices ( ) ) < 2 ) then begin Printf . printf " Only one compatible device found \ n " ; dev2 := devices . ( 0 ) end else begin Printf . printf " Wow % d compatible devices found \ n " ( Spoc . Devices . gpgpu_devices ( ) ) ; dev2 := devices . ( dev2n ) end in |
let compute ( ) = start ( ) ; Random . self_init ( ) ; let arg0 = ( " - device1 " , Arg . Int ( fun i -> dev1 := devices . ( i ) ) , " number of the device [ 0 ] " ) and arg1 = ( " - device2 " , Arg . Int ( fun i -> dev2 := devices . ( i ) ) , " number of the device [ 1 mod number_of_compatible_devices ] " ) and arg2 = ( " - size " , Arg . Int ( fun i -> vec_size := i ) , " size of the vectors to multiply [ 1024 ] " ) and arg3 = ( " - auto " , Arg . Bool ( fun b -> auto_transfers := b ; ) , " let Spoc handles transfers automatically [ false ] " ) and arg4 = ( " - verify " , Arg . Bool ( fun b -> verify := b ) , " verify computation [ true ] " ) in Arg . parse ( [ arg0 ; arg1 ; arg2 ; arg3 ; arg4 ] ) ( fun s -> ( ) ) " " ; Printf . printf " Will use devices : % s and % s \ n " ( ! dev1 ) . Spoc . Devices . general_info . Spoc . Devices . name ( ! dev2 ) . Spoc . Devices . general_info . Spoc . Devices . name ; Printf . printf " Size of vectors : % d \ n " ! vec_size ; Printf . printf " Allocating Vectors ( on CPU memory ) \ n " ; Printf . printf " Set auto - transfers % b \ n " ! auto_transfers ; Spoc . Mem . auto_transfers ! auto_transfers ; flush stdout ; let a = Spoc . Vector . create Spoc . Vector . float32 ( ! vec_size ) and b = Spoc . Vector . create Spoc . Vector . float32 ( ! vec_size ) and res = Spoc . Vector . create Spoc . Vector . float32 ( ! vec_size ) in let a1 = Spoc . Mem . sub_vector a 0 ( ! vec_size / 2 ) and b1 = Spoc . Mem . sub_vector b 0 ( ! vec_size / 2 ) and res1 = Spoc . Mem . sub_vector res 0 ( ! vec_size / 2 ) and a2 = Spoc . Mem . sub_vector a ( ! vec_size / 2 ) ( ! vec_size / 2 ) and b2 = Spoc . Mem . sub_vector b ( ! vec_size / 2 ) ( ! vec_size / 2 ) and res2 = Spoc . Mem . sub_vector res ( ! vec_size / 2 ) ( ! vec_size / 2 ) in Printf . printf " Loading Vectors with random floats \ n " ; flush stdout ; for i = 0 to ( Spoc . Vector . length a ) - 1 do Spoc . Mem . set a i ( Random . float 32 . ) ; Spoc . Mem . set b i ( ( Random . float 32 . ) ) ; done ; if ( not ! auto_transfers ) then begin Printf . printf " Transfering Vectors ( on Device memory ) \ n " ; flush stdout ; Spoc . Mem . to_device a1 ! dev1 ; Spoc . Mem . to_device b1 ! dev1 ; Spoc . Mem . to_device res1 ! dev1 ; Spoc . Mem . to_device a2 ! dev2 ; Spoc . Mem . to_device b2 ! dev2 ; Spoc . Mem . to_device res2 ! dev2 ; end ; begin Printf . printf " Computing \ n " ; flush stdout ; let threadsPerBlock dev = match dev . Devices . specific_info with | Devices . OpenCLInfo clI -> ( match clI . Devices . device_type with | Devices . CL_DEVICE_TYPE_CPU -> 1 | _ -> 256 ) | _ -> 256 in let blocksPerGrid dev = ( ! vec_size + ( threadsPerBlock dev ) - 1 ) / ( threadsPerBlock dev ) in let block dev = { Spoc . Kernel . blockX = threadsPerBlock dev ; Spoc . Kernel . blockY = 1 ; Spoc . Kernel . blockZ = 1 } and grid dev = { Spoc . Kernel . gridX = ( blocksPerGrid dev ) / 2 ; Spoc . Kernel . gridY = 1 ; Spoc . Kernel . gridZ = 1 } in vecadd # compile ~ debug : true ! dev1 ; vecadd # compile ~ debug : true ! dev2 ; Printf . printf " Computing 1st part \ n " ; flush stdout ; vecadd # run ( a1 , b1 , res1 , ( ! vec_size / 2 ) ) ( block ! dev1 , grid ! dev1 ) 0 ! dev1 ; Printf . printf " Computing 2nd part \ n " ; flush stdout ; vecadd # run ( a2 , b2 , res2 , ( ! vec_size / 2 ) ) ( block ! dev2 , grid ! dev2 ) 0 ! dev2 ; flush stdout ; end ; Printf . printf " Transfering Subvectors Back ( on CPU memory ) \ n " ; Spoc . Mem . to_cpu res1 ( ) ; Spoc . Mem . to_cpu res2 ( ) ; Spoc . Devices . flush ! dev1 ( ) ; Spoc . Devices . flush ! dev2 ( ) ; if ! verify then ( Printf . printf " Verifying Computation \ n " ; flush stdout ; let correct = ref true in begin for i = 0 to ( ( Spoc . Vector . length res ) - 1 ) do let tmp = a . [ < i ] > . + b . [ < i ] > in if ( ( Vector . float32_of_float tmp ) . - res . [ < i ] > <> 0 . ) then begin Printf . printf " ERROR Index : % d - % g <> % g ----> % g \ n " i tmp ( Spoc . Mem . get res i ) ( tmp . - ( Spoc . Mem . get res i ) ) ; Printf . printf " a [ % d ] = % g , b [ % d ] = % g \ n " i ( Spoc . Mem . get a i ) i ( Spoc . Mem . get b i ) ; correct := false ; flush stdout end ; done ; if ! correct then Printf . printf " Verif OK \ n " else Printf . printf " Verif KO \ n " end ) ; flush stdout ; let a = read_line ( ) in a in compute ( ) |
type ( ' el , ' n ) ' n t = | [ ] : ( ' el , Peano . zero ) zero t | ( :: ) : ' el * ( ' el , ' n ) ' n t -> ( ' el , ' n Peano . succ ) succ t |
let is_empty : type n . ( ' a , n ) n t -> bool = function | [ ] -> true | _ :: _ -> false |
let rec to_list : type n . ( ' a , n ) n t -> ' a list = function | [ ] -> [ ] | h :: t -> h :: to_list t |
let rec map : type n . f ( : ' a -> ' b ) ' b -> ( ' a , n ) n t -> ( ' b , n ) n t = fun ~ f ls -> match ls with [ ] -> [ ] | h :: t -> f h :: map ~ f t |
let rec map2 : type n . f ( : ' a -> ' b -> ' c ) ' c -> ( ' a , n ) n t -> ( ' b , n ) n t -> ( ' c , n ) n t = fun ~ f ls_a ls_b -> match ( ls_a , ls_b ) ls_b with | [ ] , [ ] -> [ ] | h_a :: t_a , h_b :: t_b -> f h_a h_b :: map2 ~ f t_a t_b |
let rec fold : type n . init : ' b -> f ( : ' b -> ' a -> ' b ) ' b -> ( ' a , n ) n t -> ' b = fun ~ init ~ f ls -> match ls with [ ] -> init | h :: t -> fold ~ init ( : f init h ) h ~ f t |
let rec fold_map : type n . init : ' b -> f ( : ' b -> ' a -> ' b * ' c ) ' c -> ( ' a , n ) n t -> ' b * ( ' c , n ) n t = fun ~ init ~ f ls -> match ls with | [ ] -> ( init , [ ] ) | h :: t -> let init ' , h ' = f init h in let init ' ' , t ' = fold_map ~ init : init ' ~ f t in ( init ' ' , h ' :: t ' ) t ' |
module Quickcheck_generator = struct open Core_kernel . Quickcheck open Generator . Let_syntax let rec map : type n . f ( : ' a -> ' b Generator . t ) t -> ( ' a , n ) n t -> ( ' b , n ) n t Generator . t = fun ~ f ls -> match ls with | [ ] -> return [ ] | h :: t -> let % bind h ' = f h in let % map t ' = map ~ f t in h ' :: t ' end |
let get_x ( v : t ) : float = Ctypes . getf !@ v Orx_types . Vector . x |
let get_y ( v : t ) : float = Ctypes . getf !@ v Orx_types . Vector . y |
let get_z ( v : t ) : float = Ctypes . getf !@ v Orx_types . Vector . z |
let equal_2d ( a : t ) ( b : t ) : bool = Float . equal ( get_x a ) ( get_x b ) && Float . equal ( get_y a ) ( get_y b ) |
let pp ppf ( v : t ) = Fmt . pf ppf " ( % g , % g , % g ) " ( get_x v ) ( get_y v ) ( get_z v ) |
let make ~ x ~ y ~ z : t = let v = allocate_raw ( ) in let ( _ : t ) = set v x y z in v |
let set_x ( v : t ) ( x : float ) : unit = Ctypes . setf !@ v Orx_types . Vector . x x |
let set_y ( v : t ) ( y : float ) : unit = Ctypes . setf !@ v Orx_types . Vector . y y |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.