about summary refs log blame commit diff stats
path: root/arc/.traces/convert-names-label
blob: 867825237d1996a271a6c56ce88b403362dfd71d (plain) (tree) 
b96af395 ^







1
2
3
4
5
6
7







                                                      
cn0: convert-names in 
cn0: (((1 integer)) <- ((copy)) ((0 literal))) nil nil
cn0: checking arg ((0 literal))
cn0: checking oarg ((1 integer))
maybe-add: ((1 integer))
cn1: (((1 integer)) <- ((copy)) ((0 literal)))
cn1: foo
generated by cgit-pink 1.4.1-2-gfad0 (git 2.36.2.497.gbbea4dcf42) at 2024-11-16 13:53:17 +0000
0 2864 - replace all address:shared with just address' href='/akkartik/mu/commit/043space.cc?h=hlt&id=b0bf5321de2ba32f3b92c2faf6b7b68a06b6b432'>b0bf5321 ^ 
263e6b2a ^


33262afe ^

b0bf5321 ^


10ffce98 ^

4b79c627 ^



047296d8 ^


7afe09fb ^

1ead3562 ^

bc643692 ^

047296d8 ^




e06dbec0 ^

047296d8 ^






ca01193d ^

b24eb476 ^

50eab110 ^


7da71d03 ^

c6034af3 ^

249cc081 ^

7da71d03 ^

c6034af3 ^



35064671 ^

acc4792d ^

35064671 ^

c6034af3 ^

ae256ea1 ^

c6034af3 ^

7da71d03 ^


b24eb476 ^

58eb6ee2 ^

263e6b2a ^

58eb6ee2 ^


b24eb476 ^

1e38eee5 ^

58eb6ee2 ^

b24eb476 ^

58eb6ee2 ^


1b76245c ^

58eb6ee2 ^







43b866d1 ^

3473c63a ^










58eb6ee2 ^

3473c63a ^



58eb6ee2 ^


1ead3562 ^

b0bf5321 ^


58eb6ee2 ^



43b866d1 ^

3473c63a ^





58eb6ee2 ^

7284d503 ^


286ca5a4 ^

1ead3562 ^

b0bf5321 ^




263e6b2a ^


33262afe ^

b0bf5321 ^


10ffce98 ^

b38e5819 ^



fb1fcbc9 ^


b38e5819 ^

7284d503 ^


286ca5a4 ^

1ead3562 ^

b0bf5321 ^





263e6b2a ^


33262afe ^

b0bf5321 ^


10ffce98 ^

b38e5819 ^



fb1fcbc9 ^


b38e5819 ^

a2d8c713 ^




1ead3562 ^

a2d8c713 ^

bc643692 ^


a2d8c713 ^




e06dbec0 ^

a2d8c713 ^





70f70118 ^

a2d8c713 ^

b0bf5321 ^

a2d8c713 ^


77d5b5d6 ^

a2d8c713 ^

43b866d1 ^

3473c63a ^







43b866d1 ^

3473c63a ^




a2d8c713 ^

77d5b5d6 ^




1ead3562 ^

77d5b5d6 ^




1ead3562 ^

77d5b5d6 ^

bc643692 ^

b0bf5321 ^

77d5b5d6 ^




3589c440 ^




b0bf5321 ^

3589c440 ^

b0bf5321 ^

d8f2d0b1 ^


77d5b5d6 ^







70f70118 ^

77d5b5d6 ^







795f5244 ^

12f99381 ^



e6692482 ^

d8f2d0b1 ^

b0bf5321 ^

3589c440 ^

















67573caf ^

263e6b2a ^

77d5b5d6 ^


d8f2d0b1 ^











77d5b5d6 ^

77d5b5d6 ^

acc4792d ^

e6692482 ^

77d5b5d6 ^



1b76245c ^

b0bf5321 ^

77d5b5d6 ^

0d3f30c2 ^




05331766 ^

0d3f30c2 ^




05331766 ^

0d3f30c2 ^











1b76245c ^

0d3f30c2 ^



05331766 ^

0d3f30c2 ^

05331766 ^

0d3f30c2 ^

05331766 ^

0d3f30c2 ^



b24eb476 ^

0d3f30c2 ^

e4b03c6f ^

d0e29245 ^

0d3f30c2 ^

0d3f30c2 ^



a70ce311 ^









b24eb476 ^

a70ce311 ^





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
192
193

194

195
196
197
198

199

200
201
202
203

204

205

206

207

208
209
210
211

212
213
214
215

216

217

218

219
220

221
222
223
224
225
226
227

228

229
230
231
232
233
234
235

236

237
238
239

240

241

242

243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259

260

261

262
263

264
265
266
267
268
269
270
271
272
273
274

275

276

277

278

279
280
281

282

283

284

285
286
287
288

289

290
291
292
293

294

295
296
297
298
299
300
301
302
303
304
305

306

307
308
309

310

311

312

313

314

315
316
317

318

319

320

321

322

323
324
325

326
327
328
329
330
331
332
333
334

335

336
337
338
339
340

                                                                             


                                                                              
                             

                                                                                              
          
                                                             

                                 
                                                        
                     
 
                               
 
                                          
          


                                                             

                                   
                               

                                                                                           
                                        


                              

                                                      
                     
          
                                             



                             
                                     





                                      
                           
                  

                                
 
                                         
              
       


                                        
                       
                                                                                                                              
   
                                               
                                                                  
                    

 
                                  
                                                      
                                                                                              

 
                                   
                      
                                       
                                         

                       
                                                                                                      






                                                                           
                                                 









                                                                                                                                                                 
   


                                            

                             
          

                                                                           


                              
                                          




                                                 
 

              
                                                 
          



                                                                          

                                   
                               

                                                          
                                                


                              

                                                                      
 

                
                                                   
          




                                                                      

                                   
                               

                                                          
                                                  


                              

                                                                      
 



                                                                         
          
                   

                    



                                                               
                                     




                                         
                                                        
                                 
                                                                                          

                                       
                                          
 
                                          






                                                                                                                               
                                                 



                                                                                                       
 



                                                                            
          



                                         
         
             
                     
                                             



                                                               



                                                
                                            
     
                                            

                                                                                






                                                                           
                                                        






                                                      
                                                                      


                                                       
                                             
                                                              
                                                                   
















                                                                                            
                                       
                                                                               

 










                                                                                 
                                                           
                                
                                                                                  
                    


                                                                  
                                                                   
                                                                           
 



                                                          
                                              



                                                        
                                                                                                       










                                                                                                                                         
                                                                                                          


                        
                                          
                    
                                         
                       
                                          


                                                        
                                                                                 
                                   
                                                                                                      
                                   
                  


               








                                                                 
                             




                                                                                 
//: Spaces help isolate recipes from each other. You can create them at will,
//: and all addresses in arguments are implicitly based on the 'default-space'
//: (unless they have the /raw property)

:(scenario set_default_space)
# if default-space is 10, and if an array of 5 locals lies from location 12 to 16 (inclusive),
# then local 0 is really location 12, local 1 is really location 13, and so on.
def main [
  # pretend address:array:location; in practice we'll use new
  10:number <- copy 0  # refcount
  11:number <- copy 5  # length
  default-space:address:array:location <- copy 10/unsafe
  1:number <- copy 23
]
+mem: storing 23 in location 13

:(scenario lookup_sidesteps_default_space)
def main [
  # pretend pointer from outside (2000 reserved for refcount)
  2001:number <- copy 34
  # pretend address:array:location; in practice we'll use new
  1000:number <- copy 0  # refcount
  1001:number <- copy 5  # length
  # actual start of this recipe
  default-space:address:array:location <- copy 1000/unsafe
  1:address:number <- copy 2000/unsafe  # even local variables always contain raw addresses
  8:number/raw <- copy *1:address:number
]
+mem: storing 34 in location 8

//:: first disable name conversion for 'default-space'
:(scenario convert_names_passes_default_space)
% Hide_errors = true;
def main [
  default-space:number, x:number <- copy 0, 1
]
+name: assign x 1
-name: assign default-space 1

:(before "End is_disqualified Cases")
if (x.name == "default-space")
  x.initialized = true;
:(before "End is_special_name Cases")
if (s == "default-space") return true;

//:: now implement space support
:(before "End call Fields")
int default_space;
:(before "End call Constructor")
default_space = 0;

:(before "End canonize(x) Special-cases")
absolutize(x);
:(code)
void absolutize(reagent& x) {
  if (is_raw(x) || is_dummy(x)) return;
  if (x.name == "default-space") return;
  if (!x.initialized) {
    raise << to_original_string(current_instruction()) << ": reagent not initialized: " << x.original_string << '\n' << end();
  }
  x.set_value(address(x.value, space_base(x)));
  x.properties.push_back(pair<string, string_tree*>("raw", NULL));
  assert(is_raw(x));
}

int space_base(const reagent& x) {
  // temporary stub; will be replaced in a later layer
  return current_call().default_space ? (current_call().default_space+/*skip refcount*/1) : 0;
}

int address(int offset, int base) {
  assert(offset >= 0);
  if (base == 0) return offset;  // raw
  int size = get_or_insert(Memory, base);
  if (offset >= size) {
    // todo: test
    raise << "location " << offset << " is out of bounds " << size << " at " << base << '\n' << end();
    return 0;
  }
  return base + /*skip length*/1 + offset;
}

//:: reads and writes to the 'default-space' variable have special behavior

:(after "Begin Preprocess write_memory(x, data)")
if (x.name == "default-space") {
  if (!scalar(data)
      || !x.type
      || x.type->value != get(Type_ordinal, "address")
      || !x.type->right
      || x.type->right->value != get(Type_ordinal, "array")
      || !x.type->right->right
      || x.type->right->right->value != get(Type_ordinal, "location")
      || x.type->right->right->right) {
    raise << maybe(current_recipe_name()) << "'default-space' should be of type address:array:location, but tried to write " << to_string(data) << '\n' << end();
  }
  current_call().default_space = data.at(0);
  return;
}

:(scenario get_default_space)
def main [
  default-space:address:array:location <- copy 10/unsafe
  1:address:array:location/raw <- copy default-space:address:array:location
]
+mem: storing 10 in location 1

:(after "Begin Preprocess read_memory(x)")
if (x.name == "default-space") {
  vector<double> result;
  result.push_back(current_call().default_space);
  return result;
}

//:: fix 'get'

:(scenario lookup_sidesteps_default_space_in_get)
def main [
  # pretend pointer to container from outside (2000 reserved for refcount)
  2001:number <- copy 34
  2002:number <- copy 35
  # pretend address:array:location; in practice we'll use new
  1000:number <- copy 0  # refcount
  1001:number <- copy 5  # length
  # actual start of this recipe
  default-space:address:array:location <- copy 1000/unsafe
  1:address:point <- copy 2000/unsafe
  9:number/raw <- get *1:address:point, 1:offset
]
+mem: storing 35 in location 9

:(before "Read element" following "case GET:")
element.properties.push_back(pair<string, string_tree*>("raw", NULL));

//:: fix 'index'

:(scenario lookup_sidesteps_default_space_in_index)
def main [
  # pretend pointer to array from outside (2000 reserved for refcount)
  2001:number <- copy 2  # length
  2002:number <- copy 34
  2003:number <- copy 35
  # pretend address:array:location; in practice we'll use new
  1000:number <- copy 0  # refcount
  1001:number <- copy 5  # length
  # actual start of this recipe
  default-space:address:array:location <- copy 1000/unsafe
  1:address:array:number <- copy 2000/unsafe
  9:number/raw <- index *1:address:array:number, 1
]
+mem: storing 35 in location 9

:(before "Read element" following "case INDEX:")
element.properties.push_back(pair<string, string_tree*>("raw", NULL));

//:: convenience operation to automatically deduce the amount of space to
//:: allocate in a default space with names

:(scenario new_default_space)
def main [
  new-default-space
  x:number <- copy 0
  y:number <- copy 3
]
# allocate space for x and y, as well as the chaining slot at 0
+mem: array size is 3

:(before "End is_disqualified Cases")
if (x.name == "number-of-locals")
  x.initialized = true;
:(before "End is_special_name Cases")
if (s == "number-of-locals") return true;

:(before "End Rewrite Instruction(curr, recipe result)")
// rewrite `new-default-space` to
//   `default-space:address:array:location <- new location:type, number-of-locals:literal`
// where N is Name[recipe][""]
if (curr.name == "new-default-space") {
  rewrite_default_space_instruction(curr);
}
:(after "Begin Preprocess read_memory(x)")
if (x.name == "number-of-locals") {
  vector<double> result;
  result.push_back(Name[get(Recipe_ordinal, current_recipe_name())][""]);
  if (result.back() == 0)
    raise << "no space allocated for default-space in recipe " << current_recipe_name() << "; are you using names?\n" << end();
  return result;
}
:(after "Begin Preprocess write_memory(x, data)")
if (x.name == "number-of-locals") {
  raise << maybe(current_recipe_name()) << "can't write to special name 'number-of-locals'\n" << end();
  return;
}

//:: a little hook to automatically reclaim the default-space when returning
//:: from a recipe

:(scenario local_scope)
def main [
  1:address <- foo
  2:address <- foo
  3:boolean <- equal 1:address, 2:address
]
def foo [
  local-scope
  x:number <- copy 34
  return default-space:address:array:location
]
# both calls to foo should have received the same default-space
+mem: storing 1 in location 3

:(code)  // pending test
//? :(scenario local_scope_frees_up_allocations)
//? def main [
//?   local-scope
//?   x:address:array:character <- new [abc]
//? ]
//? +mem: clearing x:address:array:character

//: todo: do this in a transform, rather than magically in the reply instruction
:(after "Falling Through End Of Recipe")
try_reclaim_locals();
:(after "Starting Reply")
try_reclaim_locals();

//: now 'local-scope' is identical to 'new-default-space' except that we'll
//: reclaim the default-space when the routine exits
:(before "End Rewrite Instruction(curr, recipe result)")
if (curr.name == "local-scope") {
  rewrite_default_space_instruction(curr);
}

:(code)
void try_reclaim_locals() {
  // only reclaim routines starting with 'local-scope'
  const recipe_ordinal r = get(Recipe_ordinal, current_recipe_name());
  const recipe& exiting_recipe = get(Recipe, r);
  if (exiting_recipe.steps.empty()) return;
  const instruction& inst = exiting_recipe.steps.at(0);
  if (inst.old_name != "local-scope") return;
  // reclaim any local variables unless they're being returned
  // TODO: this isn't working yet. Doesn't handle address stored in
  // containers created by 'copy' or 'merge'. We'd end up deleting the address
  // even if some container containing it was returned.
  // This might doom our whole refcounting-based approach :/
//?   vector<double> zero;
//?   zero.push_back(0);
//?   for (int i = /*leave default space for last*/1; i < SIZE(exiting_recipe.steps); ++i) {
//?     const instruction& inst = exiting_recipe.steps.at(i);
//?     for (int i = 0; i < SIZE(inst.products); ++i) {
//?       if (!is_mu_address(inst.products.at(i))) continue;
//?       // local variables only
//?       if (has_property(inst.products.at(i), "space")) continue;
//?       if (has_property(inst.products.at(i), "lookup")) continue;
//?       if (escaping(inst.products.at(i))) continue;
//?       trace(9999, "mem") << "clearing " << inst.products.at(i).original_string << end();
//?       write_memory(inst.products.at(i), zero);
//?     }
//?   }
  abandon(current_call().default_space,
          /*refcount*/1 + /*array length*/1 + /*number-of-locals*/Name[r][""]);
}

// is this reagent one of the values returned by the current (reply) instruction?
bool escaping(const reagent& r) {
  // nothing escapes when you fall through past end of recipe
  if (current_step_index() >= SIZE(Current_routine->steps())) return false;
  for (long long i = 0; i < SIZE(current_instruction().ingredients); ++i) {
    if (r == current_instruction().ingredients.at(i))
      return true;
  }
  return false;
}

void rewrite_default_space_instruction(instruction& curr) {
  if (!curr.ingredients.empty())
    raise << to_original_string(curr) << " can't take any ingredients\n" << end();
  curr.name = "new";
  curr.ingredients.push_back(reagent("location:type"));
  curr.ingredients.push_back(reagent("number-of-locals:literal"));
  if (!curr.products.empty())
    raise << "new-default-space can't take any results\n" << end();
  curr.products.push_back(reagent("default-space:address:array:location"));
}

//:: all recipes must set default-space one way or another

:(before "End Globals")
bool Hide_missing_default_space_errors = true;
:(before "End Checks")
Transform.push_back(check_default_space);  // idempotent
:(code)
void check_default_space(const recipe_ordinal r) {
  if (Hide_missing_default_space_errors) return;  // skip previous core tests; this is only for mu code
  const recipe& caller = get(Recipe, r);
  // skip scenarios (later layer)
  // user code should never create recipes with underscores in their names
  if (caller.name.find("scenario_") == 0) return;  // skip mu scenarios which will use raw memory locations
  if (caller.name.find("run_") == 0) return;  // skip calls to 'run', which should be in scenarios and will also use raw memory locations
  // assume recipes with only numeric addresses know what they're doing (usually tests)
  if (!contains_non_special_name(r)) return;
  trace(9991, "transform") << "--- check that recipe " << caller.name << " sets default-space" << end();
  if (caller.steps.empty()) return;
  if (caller.steps.at(0).products.empty()
      || caller.steps.at(0).products.at(0).name != "default-space") {
    raise << maybe(caller.name) << " does not seem to start with default-space or local-scope\n" << end();
  }
}
:(after "Load .mu Core")
Hide_missing_default_space_errors = false;
:(after "Test Runs")
Hide_missing_default_space_errors = true;
:(after "Running Main")
Hide_missing_default_space_errors = false;

:(code)
bool contains_non_special_name(const recipe_ordinal r) {
  for (map<string, int>::iterator p = Name[r].begin(); p != Name[r].end(); ++p) {
    if (p->first.empty()) continue;
    if (p->first.find("stash_") == 0) continue;  // generated by rewrite_stashes_to_text (cross-layer)
    if (!is_special_name(p->first))
      return true;
  }
  return false;
}

// reagent comparison -- only between reagents in a single recipe
bool operator==(const reagent& a, const reagent& b) {
  if (a.name != b.name) return false;
  if (property(a, "space") != property(b, "space")) return false;
  return true;
}

bool operator<(const reagent& a, const reagent& b) {
  int aspace = 0, bspace = 0;
  if (has_property(a, "space")) aspace = to_integer(property(a, "space")->value);
  if (has_property(b, "space")) bspace = to_integer(property(b, "space")->value);
  if (aspace != bspace) return aspace < bspace;
  return a.name < b.name;
}
generated by cgit-pink 1.4.1-2-gfad0 (git 2.36.2.497.gbbea4dcf42) at 2024-11-16 13:53:16 +0000