Mercurial > repos > rhope

comparison nworker.rhope @ 49:3e20ed8959c4

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Added initial FFI implementation, Array type and 64-bit integers
author Mike Pavone <pavone@retrodev.com>
date Thu, 08 Apr 2010 01:02:18 -0400
parents a24eb366195c
children 689fb73e7612
comparison
equal deleted inserted replaced
48:a24eb366195c 49:3e20ed8959c4
294 Uses 294 Uses
295 NodeResults 295 NodeResults
296 Free Temps 296 Free Temps
297 Name 297 Name
298 Builtin? 298 Builtin?
299 Library
299 } 300 }
300 301
301 NWorker[convention:out] 302 NWorker[convention:out]
302 { 303 {
303 out <- [[[[[[[[Build["NWorker"]]Convention <<[convention]]Nodes <<[()]]Inputs <<[()]]Outputs <<[()]]Input Types <<[()]]Output Types <<[()]]Name <<["Anonymous"]]Builtin? <<[No] 304 out <- [[[[[[[[[Build["NWorker"]]Convention <<[convention]]Nodes <<[()]]Inputs <<[()]]Outputs <<[()]]Input Types <<[()]]Output Types <<[()]]Name <<["Anonymous"]]Builtin? <<[No]]Library << [""]
304 } 305 }
305 306
306 Add Node@NWorker[worker,type,data,inputs,outputs:out,node index] 307 Add Node@NWorker[worker,type,data,inputs,outputs:out,node index]
307 { 308 {
308 out <- [worker]Nodes <<[[[worker]Nodes >>]Append[NWorker Node[type,data,inputs,outputs]]] 309 out <- [worker]Nodes <<[[[worker]Nodes >>]Append[NWorker Node[type,data,inputs,outputs]]]
730 Print["Method!"] 731 Print["Method!"]
731 with call <- [func]Method Call[[[node]Data >>]Name >>, inputs] 732 with call <- [func]Method Call[[[node]Data >>]Name >>, inputs]
732 { Print["Method Call done"] } 733 { Print["Method Call done"] }
733 }{ 734 }{
734 Print["Function!"] 735 Print["Function!"]
735 with call <- [func]Call[[[node]Data >>]Name >>, inputs] 736 {
737 Pretty Print[inputs, ""]
738 { with call <- [func]Call[[[node]Data >>]Name >>, inputs]}
739 }
740
736 } 741 }
737 } 742 }
738 } 743 }
739 } 744 }
740 out <- Fold[["Save Result"]Set Input[2, node index], with call, Range[0, [node]Outputs >>]] 745 out <- Fold[["Save Result"]Set Input[2, node index], with call, Range[0, [node]Outputs >>]]
761 } 766 }
762 nstream <- Compile Call Node[node, program, stream, inputs, node index] 767 nstream <- Compile Call Node[node, program, stream, inputs, node index]
763 }{ 768 }{
764 If[[[node]Type >>] = ["output"]] 769 If[[[node]Type >>] = ["output"]]
765 { 770 {
771 Print["Compiling output node"]
766 inputs <- [worker]Collect Inputs[node] 772 inputs <- [worker]Collect Inputs[node]
767 [conditions]For Backend 773 [conditions]For Backend
768 { 774 {
775 Print["has conditions"]
769 stream <- [func]Instruction Stream 776 stream <- [func]Instruction Stream
770 nfunc <- [func]Do If[~, nstream] 777 nfunc <- [func]Do If[~, nstream]
771 }{ 778 }{
779 Print["no conditions"]
772 stream <- Val[func] 780 stream <- Val[func]
773 nfunc <- Val[nstream] 781 nfunc <- Val[nstream]
774 } 782 }
775 nstream <- [stream]Move[[inputs]Index[0], [[worker]Outputs >>]Index[ [node]Data >> ] ] 783 nstream <- [stream]Move[[inputs]Index[0], [[worker]Outputs >>]Index[ [node]Data >> ] ]
776 }{ 784 }{
865 Result Vars@NWorker[worker:out] 873 Result Vars@NWorker[worker:out]
866 { 874 {
867 out <- Fold["Node Result Vars", (), [worker]Nodes >>] 875 out <- Fold["Node Result Vars", (), [worker]Nodes >>]
868 } 876 }
869 877
878 Make Basic Type[type:out]
879 {
880 out <- [Type Instance[[type]Name >>]]Params <<[ [type]Params >> ]
881 }
882
883 FInputs[ifunc, input type, index, inputs:out]
884 {
885 func <- [ifunc]Set Input Type[Make Basic Type[input type], index]
886 name <- [inputs]Index[index]
887 Print[["FInputs: "]Append[index]]
888 Pretty Print[input type, ""]
889 {
890 If[[[input type]Variant >>] = ["Naked"]]
891 {
892
893 naked <- [" naked"]Append[name]
894
895 out <- [[[func]Allocate Var[naked, input type]
896 ]Unbox[name, naked]
897 ]Release[name]
898 }{
899 If[[input type]Mutable? >>]
900 {
901 name <- [inputs]Index[index]
902 copied <- [func]Copy[name, name]
903
904 }{
905 copied <- Val[func]
906 }
907 If[[[input type]Variant >>] = ["Raw Pointer"]]
908 {
909 raw <- [" raw"]Append[name]
910 If[[[input type]Name >>]=["Array"]]
911 {
912
913 out <- [[copied]Allocate Var[raw, input type]
914 ]Array Raw Pointer[name, raw]
915 }{
916 out <- [[copied]Allocate Var[raw, input type]
917 ]Get Raw Pointer[name, raw]
918 }
919 }{
920 out <- Val[copied]
921 }
922 }
923 }
924 }
925
926 FParams[input:out]
927 {
928 iname <- [input]Index[0]
929 type <- [input]Index[1]
930 If[[[type]Variant >>] = ["Naked"]]
931 { out <- [" naked"]Append[iname] }
932 {
933 If[[[type]Variant >>] = ["Raw Pointer"]]
934 { out <- [" raw"]Append[iname] }
935 { out <- Val[iname] }
936 }
937 }
938 _Return Param[outputs, inputs, input types, index:out,none]
939 {
940 Print[["_Return Param: "]Append[output]]
941 output <- [outputs]Index[index]
942 [inputs]Find[output]
943 {
944 If[[[input types]Index[~]]Mutable? >>]
945 {
946 ,none <- [outputs]Next[index]
947 {
948 out,none <- _Return Param[outputs, index, input types, ~]
949 }
950 } {
951 out <- index
952 }
953 }{
954 out <- index
955 }
956 }
957
958 Return Param[outputs, inputs, input types:out,none]
959 {
960 Print["Return Param"]
961 ,none <- [outputs]First
962 { out,none <- _Return Param[outputs, inputs, input types, ~] }
963
964 }
965
966 Save Foreign Result[func, output, index, output types, inputs, input types:out]
967 {
968 type <- [output types]Index[index]
969 If[[[type]Variant >>] = ["Naked"]]
970 {
971 out <- [func]Box[[" naked"]Append[output], output, type]
972 }{
973 [inputs]Find[output]
974 {
975 If[[[input types]Index[~]]Mutable? >>]
976 {
977 out <- [func]Move[output, Output[output]]
978 }{
979 out <- func
980 }
981 }{
982 out <- func
983 }
984 }
985 }
986
987 Compile Foreign Stub[worker,program,name:out]
988 {
989 Print[["Compiling FFI stub for "]Append[name]]
990 ifunc <- [[program]Create Function[name, [worker]Inputs >>, [worker]Outputs >>, "rhope"]
991 ]Output Types <<[Map[[worker]Output Types >>, "Make Basic Type"]]
992
993 rp num <- Return Param[[worker]Outputs >>, [worker]Inputs >>, [worker]Input Types >>]
994 {
995 rbase <- [[worker]Outputs >>]Index[rp num]
996 If[[[[[worker]Output Types >>]Index[rp num]]Variant >>] = ["Naked"]]
997 {
998 rparam <- [" naked"]Append[rbase]
999 rfunc <- [ifunc]Allocate Var[rparam, [[worker]Output Types >>]Index[rp num]]
1000 }{
1001 rparam <- Val[rbase]
1002 rfunc <- Val[ifunc]
1003 }
1004 }{
1005 rparam <- ""
1006 rfunc <- Val[ifunc]
1007 }
1008
1009 Fold[["FInputs"]Set Input[3, [worker]Inputs >>], rfunc, [worker]Input Types >>]
1010 { [~]Call Foreign[name, [worker]Convention >>, Map[Zip[[worker]Inputs >>, [worker]Input Types >>], "FParams"], rparam]
1011 { Fold[[[["Save Foreign Result"]Set Input[3, [worker]Output Types >>]]Set Input[4, [worker]Inputs >>]]Set Input[5, [worker]Input Types >>], ~, [worker]Outputs >>]
1012 { out <- [program]Store Function[~] }}}
1013 }
1014
870 Compile Worker@NWorker[worker,program,name:out] 1015 Compile Worker@NWorker[worker,program,name:out]
871 { 1016 {
872 If[[worker]Builtin? >>] 1017 If[[worker]Builtin? >>]
873 { 1018 {
874 out <- program 1019 out <- program
875 }{ 1020 }{
876 Print[["Compiling: "]Append[name]] 1021 If[[[worker]Library >>] = [""]]
877 { 1022 {
878 ifunc <- Fold["Set Output Type", Fold["Set Input Type", [program]Create Function[name,[worker]Inputs >>, [worker]Outputs >>, [worker]Convention >>], [worker]Input Types >>], [worker]Output Types >>] 1023 Print[["Compiling: "]Append[name]]
879 1024 {
880 res vars <- [worker]Result Vars 1025 ifunc <- Fold["Set Output Type", Fold["Set Input Type", [program]Create Function[name,[worker]Inputs >>, [worker]Outputs >>, [worker]Convention >>], [worker]Input Types >>], [worker]Output Types >>]
881 func <- Fold["Set Null", Fold["Set Null", Fold[["Allocate Var"]Set Input[2, "Any Type"], ifunc, res vars], res vars], [worker]Outputs >>] 1026
882 1027 res vars <- [worker]Result Vars
883 groups <- [worker]Dependency Groups 1028 func <- Fold["Set Null", Fold["Set Null", Fold[["Allocate Var"]Set Input[2, "Any Type"], ifunc, res vars], res vars], [worker]Outputs >>]
884 [groups]First 1029
885 { 1030 groups <- [worker]Dependency Groups
886 final func <- [worker]Compile Group[program,func,groups, ~] 1031 [groups]First
887 }{ 1032 {
888 final func <- Val[func] 1033 final func <- [worker]Compile Group[program,func,groups, ~]
889 } 1034 }{
890 out <- [program]Store Function[Fold["Release", Fold[["Release Var"]Set Input[0, worker], final func, res vars], [worker]Inputs >>]] 1035 final func <- Val[func]
1036 }
1037 out <- [program]Store Function[Fold["Release", Fold[["Release Var"]Set Input[0, worker], final func, res vars], [worker]Inputs >>]]
1038 }
1039 }{
1040 out <- Compile Foreign Stub[worker,[program]Link[[worker]Convention >>, [worker]Library >> ],name]
891 } 1041 }
892 } 1042 }
893 } 1043 }
894 1044
895 Test[:out] 1045 Test[:out]
1115 { 1265 {
1116 after bind <- [prog]Workers << [ [[prog]Workers >>]Set[name, [worker]Name <<[name]] ] 1266 after bind <- [prog]Workers << [ [[prog]Workers >>]Set[name, [worker]Name <<[name]] ]
1117 parts <- [name]Split["@"] 1267 parts <- [name]Split["@"]
1118 [parts]Index[1] 1268 [parts]Index[1]
1119 { 1269 {
1120 out <- [after bind]Blueprints <<[ [[after bind]Blueprints >>]Set[~, [[[after bind]Blueprints >>]Index[~]]Add Method[[parts]Index[0]] ] ] 1270 orig bp <- [[after bind]Blueprints >>]Index[~] {}
1271 { orig bp <- NBlueprint[] }
1272 out <- [after bind]Blueprints <<[ [[after bind]Blueprints >>]Set[~, [orig bp]Add Method[[parts]Index[0]] ] ]
1121 }{ 1273 }{
1122 out <- Val[after bind] 1274 out <- Val[after bind]
1123 } 1275 }
1124 } 1276 }
1125 1277
1176 } 1328 }
1177 } 1329 }
1178 1330
1179 Register Builtins@NProgram[prog:out] 1331 Register Builtins@NProgram[prog:out]
1180 { 1332 {
1181 registered <- [[[[prog]Register Worker["Print", "rhope", 1, 1] 1333 registered <- [[[[[prog]Register Worker["Print", "rhope", 1, 1]
1182 ]Register Worker["If@Boolean", "rhope", 1, 2] 1334 ]Register Worker["If@Boolean", "rhope", 1, 2]
1183 ]Register Worker["Build", "rhope", 1, 1] 1335 ]Register Worker["Build", "rhope", 1, 1]
1336 ]Register Worker["Blueprint Of", "rhope", 1, 1]
1184 ]Register Number Methods 1337 ]Register Number Methods
1185 1338
1186 out <- [[[registered]Bind Worker["If@Boolean", 1339 out <- [[[[registered]Bind Worker["If@Boolean",
1187 [[[[[NWorker["rhope"] 1340 [[[[[NWorker["rhope"]
1188 ]Inputs <<[("condition")] 1341 ]Inputs <<[("condition")]
1189 ]Input Types <<[ [()]Append[Type Instance["Boolean"]] ] 1342 ]Input Types <<[ [()]Append[Type Instance["Boolean"]] ]
1190 ]Outputs <<[("isyes","isno")] 1343 ]Outputs <<[("isyes","isno")]
1191 ]Output Types <<[ [[()]Append[Type Instance["Boolean"]]]Append[Type Instance["Boolean"]] ] 1344 ]Output Types <<[ [[()]Append[Type Instance["Boolean"]]]Append[Type Instance["Boolean"]] ]
1202 ]Inputs <<[("type")] 1355 ]Inputs <<[("type")]
1203 ]Input Types <<[ [()]Append[Type Instance["Blueprint"]] ] 1356 ]Input Types <<[ [()]Append[Type Instance["Blueprint"]] ]
1204 ]Outputs <<[("out")] 1357 ]Outputs <<[("out")]
1205 ]Output Types <<[ [()]Append[Type Instance["Any Type"]] ] 1358 ]Output Types <<[ [()]Append[Type Instance["Any Type"]] ]
1206 ]Builtin? <<[Yes]] 1359 ]Builtin? <<[Yes]]
1360 ]Bind Worker["Blueprint Of",
1361 [[[[[NWorker["rhope"]
1362 ]Inputs <<[("object")]
1363 ]Input Types <<[ [()]Append[Type Instance["Any Type"]]]
1364 ]Outputs <<[("type")]
1365 ]Output Types <<[ [()]Append[Type Instance["Blueprint"]]]
1366 ]Builtin? <<[Yes]]
1207 } 1367 }
1208 1368
1209 Find Worker@NProgram[prog, name:out,notfound] 1369 Find Worker@NProgram[prog, name:out,notfound]
1210 { 1370 {
1211 Print[ ["Find Worker@NProgram: "]Append[name] ] 1371 Print[ ["Find Worker@NProgram: "]Append[name] ]