summary refs log blame commit diff stats
path: root/tests/threads/treusetvar.nim
blob: f0337801a09381680e0f0041d20a2dfdf7c9fd2a (plain) (tree) 
254fbcc54 ^

cdbf5b469 ^

808863325 ^

254fbcc54 ^


808863325 ^

254fbcc54 ^








808863325 ^

254fbcc54 ^














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

           
                
                 

   
            







                        
                   













                                                     
discard """
  disabled: i386
  outputsub: "65"
"""

import locks

type
  MarkerObj = object
    lock: Lock
    counter: int
  Marker = ptr MarkerObj

const
  ThreadsCount = 65

proc worker(p: Marker) {.thread.} =
  acquire(p.lock)
  inc(p.counter)
  release(p.lock)

var p = cast[Marker](allocShared0(sizeof(MarkerObj)))
initLock(p.lock)

for i in 0..(ThreadsCount - 1):
  var thread: Thread[Marker]
  createThread(thread, worker, p)
  joinThread(thread)
echo p.counter
generated by cgit-pink 1.4.1-2-gfad0 (git 2.36.2.497.gbbea4dcf42) at 2025-02-08 02:15:03 +0000
2018-05-18 15:18:00 +0200 committer Andreas Rumpf <rumpf_a@web.de> 2018-05-18 15:18:00 +0200 platform.nim doesn't use globals anymore; prepare msgs.nim for not using globals' href='/ahoang/Nim/commit/compiler/ccgmerge.nim?h=devel&id=a4e2b0c1538134ebf105b669da13db13b5356998'>a4e2b0c15 ^ 
a6f90d4cd ^

860cbd310 ^

a6f90d4cd ^




a4e2b0c15 ^

a6f90d4cd ^


860cbd310 ^

a6f90d4cd ^

860cbd310 ^

a6f90d4cd ^



594674797 ^

a6f90d4cd ^




a4e2b0c15 ^

a6f90d4cd ^





5d63ecb3a ^

39049e151 ^

050789a8f ^

a4e2b0c15 ^

a6f90d4cd ^




860cbd310 ^



a6f90d4cd ^


3ac6bd8ae ^


a4e2b0c15 ^

39049e151 ^

a6f90d4cd ^

39ebe2175 ^

a6f90d4cd ^





b731e6ef1 ^


a6f90d4cd ^








b731e6ef1 ^


a6f90d4cd ^

5d63ecb3a ^

a6f90d4cd ^







182ab85dc ^





39049e151 ^

a6f90d4cd ^

76885c754 ^

a6f90d4cd ^

1102b8ac6 ^

a6f90d4cd ^

b731e6ef1 ^

a4e2b0c15 ^

a6f90d4cd ^

b731e6ef1 ^

a4e2b0c15 ^

182ab85dc ^

050789a8f ^

182ab85dc ^

5d63ecb3a ^

1102b8ac6 ^

182ab85dc ^

a6f90d4cd ^

1102b8ac6 ^

182ab85dc ^

a6f90d4cd ^

39049e151 ^

a6f90d4cd ^

182ab85dc ^

a6f90d4cd ^

182ab85dc ^

1102b8ac6 ^


a6f90d4cd ^

1102b8ac6 ^

a6f90d4cd ^


860cbd310 ^

050789a8f ^

a6f90d4cd ^



860cbd310 ^

050789a8f ^

a6f90d4cd ^

226595515 ^

a6f90d4cd ^


594674797 ^

050789a8f ^

a6f90d4cd ^








182ab85dc ^

a6f90d4cd ^





182ab85dc ^

a6f90d4cd ^



860cbd310 ^


a6f90d4cd ^

3ac6bd8ae ^


050789a8f ^

5e15dec17 ^

86556ebfd ^

92b8fac94 ^

a6f90d4cd ^

5e15dec17 ^

a6f90d4cd ^

5e15dec17 ^

a6f90d4cd ^



43eace163 ^


5d63ecb3a ^

86556ebfd ^

43eace163 ^


182ab85dc ^

43eace163 ^

a6f90d4cd ^

43eace163 ^



e65c296bc ^

43eace163 ^



86556ebfd ^

43eace163 ^


182ab85dc ^

5d63ecb3a ^

73c6efdf6 ^

a6f90d4cd ^








43eace163 ^

a6f90d4cd ^



43eace163 ^

a6f90d4cd ^

050789a8f ^

a6f90d4cd ^

050789a8f ^

43eace163 ^


182ab85dc ^


c40249cd4 ^

182ab85dc ^

13e659cfe ^

5d63ecb3a ^

c40249cd4 ^

182ab85dc ^

43eace163 ^

86556ebfd ^

43eace163 ^


dce8d3d1a ^

5d63ecb3a ^

13e659cfe ^

39049e151 ^

13e659cfe ^

39049e151 ^

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


 
                            
                                         








                                                                          

                                                                







                                                                        
                                               





                                               
                              
                              

                                       
                                             











                                                     
                                          
 
                                                                 



                                                                       
                                   
                


                                     
 

                                                               
                                         
 

                                                                 
                     


                                     
 

                                                               
                                         
 
                                                  



                            
                 

                
                     
              
                        


            
                                            



                    
                 




                    
 
                                      
                                                      
                                 



                                  


                                    

                         

                                   
               
                 
 
                                            




                                   

                                            







                                      

                                            
                  
           






                                              




                                                                           
                                                   
                    
                                
             
                   
          
                                       
                 
          
                                       
                 
            
                                                               
           
         
                               
                                    
             
                       
             
                
                 
 
                                                     
                    
                   

                                 
           
                                                                 

                               
                                                              
                                                                


                         
                                        
                                                                  
                
                                      

              
                                                        
                                                                







                                                      
                                         




                                                 
                 


                                                   

                                                 
                                                          

                                                                        
                                                        
 
                                                            
                                         
                     
                              
                     
                                                                  


                               

                   
 
                                                          

                                               
                 
                             
                            


           
                         


                     
                                                                        

                                       
                 
                             
             







                                                              
                                               


                                                                 
                                                 
             
                                                            
         
                                                

                                       

                                
                                         
                 
                         
                              
                                                  
                 
 
                                                       

                                                         
                                   
                                                 
                         
                              
                         
                                                
#
#
#           The Nim Compiler
#        (c) Copyright 2012 Andreas Rumpf
#
#    See the file "copying.txt", included in this
#    distribution, for details about the copyright.
#

## This module implements the merge operation of 2 different C files. This
## is needed for incremental compilation.

import
  ast, ropes, options, strutils, nimlexbase, cgendata, rodutils,
  intsets, llstream, tables, modulegraphs, pathutils

# Careful! Section marks need to contain a tabulator so that they cannot
# be part of C string literals.

const
  CFileSectionNames: array[TCFileSection, string] = [
    cfsMergeInfo: "",
    cfsHeaders: "NIM_merge_HEADERS",
    cfsFrameDefines: "NIM_merge_FRAME_DEFINES",
    cfsForwardTypes: "NIM_merge_FORWARD_TYPES",
    cfsTypes: "NIM_merge_TYPES",
    cfsSeqTypes: "NIM_merge_SEQ_TYPES",
    cfsFieldInfo: "NIM_merge_FIELD_INFO",
    cfsTypeInfo: "NIM_merge_TYPE_INFO",
    cfsProcHeaders: "NIM_merge_PROC_HEADERS",
    cfsData: "NIM_merge_DATA",
    cfsVars: "NIM_merge_VARS",
    cfsProcs: "NIM_merge_PROCS",
    cfsInitProc: "NIM_merge_INIT_PROC",
    cfsDatInitProc: "NIM_merge_DATINIT_PROC",
    cfsTypeInit1: "NIM_merge_TYPE_INIT1",
    cfsTypeInit2: "NIM_merge_TYPE_INIT2",
    cfsTypeInit3: "NIM_merge_TYPE_INIT3",
    cfsDebugInit: "NIM_merge_DEBUG_INIT",
    cfsDynLibInit: "NIM_merge_DYNLIB_INIT",
    cfsDynLibDeinit: "NIM_merge_DYNLIB_DEINIT",
  ]
  CProcSectionNames: array[TCProcSection, string] = [
    cpsLocals: "NIM_merge_PROC_LOCALS",
    cpsInit: "NIM_merge_PROC_INIT",
    cpsStmts: "NIM_merge_PROC_BODY"
  ]
  NimMergeEndMark = "/*\tNIM_merge_END:*/"

proc genSectionStart*(fs: TCFileSection; conf: ConfigRef): Rope =
  # useful for debugging and only adds at most a few lines in each file
  result.add("\n/* section: ")
  result.add(CFileSectionNames[fs])
  result.add(" */\n")
  if compilationCachePresent(conf):
    result = nil
    result.add("\n/*\t")
    result.add(CFileSectionNames[fs])
    result.add(":*/\n")

proc genSectionEnd*(fs: TCFileSection; conf: ConfigRef): Rope =
  if compilationCachePresent(conf):
    result = rope(NimMergeEndMark & "\n")

proc genSectionStart*(ps: TCProcSection; conf: ConfigRef): Rope =
  if compilationCachePresent(conf):
    result = rope("")
    result.add("\n/*\t")
    result.add(CProcSectionNames[ps])
    result.add(":*/\n")

proc genSectionEnd*(ps: TCProcSection; conf: ConfigRef): Rope =
  if compilationCachePresent(conf):
    result = rope(NimMergeEndMark & "\n")

proc writeTypeCache(a: TypeCache, s: var string) =
  var i = 0
  for id, value in pairs(a):
    if i == 10:
      i = 0
      s.add('\L')
    else:
      s.add(' ')
    encodeStr($id, s)
    s.add(':')
    encodeStr($value, s)
    inc i
  s.add('}')

proc writeIntSet(a: IntSet, s: var string) =
  var i = 0
  for x in items(a):
    if i == 10:
      i = 0
      s.add('\L')
    else:
      s.add(' ')
    encodeVInt(x, s)
    inc i
  s.add('}')

proc genMergeInfo*(m: BModule): Rope =
  if not compilationCachePresent(m.config): return nil
  var s = "/*\tNIM_merge_INFO:\n"
  s.add("typeCache:{")
  writeTypeCache(m.typeCache, s)
  s.add("declared:{")
  writeIntSet(m.declaredThings, s)
  when false:
    s.add("typeInfo:{")
    writeIntSet(m.typeInfoMarker, s)
  s.add("labels:")
  encodeVInt(m.labels, s)
  s.add(" flags:")
  encodeVInt(cast[int](m.flags), s)
  s.add("\n*/")
  result = s.rope

template `^`(pos: int): untyped = L.buf[pos]

proc skipWhite(L: var TBaseLexer) =
  var pos = L.bufpos
  while true:
    case ^pos
    of CR: pos = nimlexbase.handleCR(L, pos)
    of LF: pos = nimlexbase.handleLF(L, pos)
    of ' ': inc pos
    else: break
  L.bufpos = pos

proc skipUntilCmd(L: var TBaseLexer) =
  var pos = L.bufpos
  while true:
    case ^pos
    of CR: pos = nimlexbase.handleCR(L, pos)
    of LF: pos = nimlexbase.handleLF(L, pos)
    of '\0': break
    of '/':
      if ^(pos+1) == '*' and ^(pos+2) == '\t':
        inc pos, 3
        break
      inc pos
    else: inc pos
  L.bufpos = pos

proc atEndMark(buf: cstring, pos: int): bool =
  var s = 0
  while s < NimMergeEndMark.len and buf[pos+s] == NimMergeEndMark[s]: inc s
  result = s == NimMergeEndMark.len

proc readVerbatimSection(L: var TBaseLexer): Rope =
  var pos = L.bufpos
  var r = newStringOfCap(30_000)
  while true:
    case L.buf[pos]
    of CR:
      pos = nimlexbase.handleCR(L, pos)
      r.add('\L')
    of LF:
      pos = nimlexbase.handleLF(L, pos)
      r.add('\L')
    of '\0':
      doAssert(false, "ccgmerge: expected: " & NimMergeEndMark)
      break
    else:
      if atEndMark(L.buf, pos):
        inc pos, NimMergeEndMark.len
        break
      r.add(L.buf[pos])
      inc pos
  L.bufpos = pos
  result = r.rope

proc readKey(L: var TBaseLexer, result: var string) =
  var pos = L.bufpos
  setLen(result, 0)
  while L.buf[pos] in IdentChars:
    result.add(L.buf[pos])
    inc pos
  if L.buf[pos] != ':': doAssert(false, "ccgmerge: ':' expected")
  L.bufpos = pos + 1 # skip ':'

proc readTypeCache(L: var TBaseLexer, result: var TypeCache) =
  if ^L.bufpos != '{': doAssert(false, "ccgmerge: '{' expected")
  inc L.bufpos
  while ^L.bufpos != '}':
    skipWhite(L)
    var key = decodeStr(L.buf, L.bufpos)
    if ^L.bufpos != ':': doAssert(false, "ccgmerge: ':' expected")
    inc L.bufpos
    discard decodeStr(L.buf, L.bufpos)
  inc L.bufpos

proc readIntSet(L: var TBaseLexer, result: var IntSet) =
  if ^L.bufpos != '{': doAssert(false, "ccgmerge: '{' expected")
  inc L.bufpos
  while ^L.bufpos != '}':
    skipWhite(L)
    var key = decodeVInt(L.buf, L.bufpos)
    result.incl(key)
  inc L.bufpos

proc processMergeInfo(L: var TBaseLexer, m: BModule) =
  var k = newStringOfCap("typeCache".len)
  while true:
    skipWhite(L)
    if ^L.bufpos == '*' and ^(L.bufpos+1) == '/':
      inc(L.bufpos, 2)
      break
    readKey(L, k)
    case k
    of "typeCache": readTypeCache(L, m.typeCache)
    of "declared":  readIntSet(L, m.declaredThings)
    of "typeInfo":
      when false: readIntSet(L, m.typeInfoMarker)
    of "labels":    m.labels = decodeVInt(L.buf, L.bufpos)
    of "flags":
      m.flags = cast[set[CodegenFlag]](decodeVInt(L.buf, L.bufpos) != 0)
    else: doAssert(false, "ccgmerge: unknown key: " & k)

template withCFile(cfilename: AbsoluteFile, body: untyped) =
  var s = llStreamOpen(cfilename, fmRead)
  if s == nil: return
  var L {.inject.}: TBaseLexer
  openBaseLexer(L, s)
  var k {.inject.} = newStringOfCap("NIM_merge_FORWARD_TYPES".len)
  while true:
    skipUntilCmd(L)
    if ^L.bufpos == '\0': break
    body
  closeBaseLexer(L)

proc readMergeInfo*(cfilename: AbsoluteFile, m: BModule) =
  ## reads the merge meta information into `m`.
  withCFile(cfilename):
    readKey(L, k)
    if k == "NIM_merge_INFO":
      processMergeInfo(L, m)
      break

type
  TMergeSections = object
    f: TCFileSections
    p: TCProcSections

proc readMergeSections(cfilename: AbsoluteFile, m: var TMergeSections) =
  ## reads the merge sections into `m`.
  withCFile(cfilename):
    readKey(L, k)
    if k == "NIM_merge_INFO":
      discard
    elif ^L.bufpos == '*' and ^(L.bufpos+1) == '/':
      inc(L.bufpos, 2)
      # read back into section
      skipWhite(L)
      var verbatim = readVerbatimSection(L)
      skipWhite(L)
      var sectionA = CFileSectionNames.find(k)
      if sectionA > 0 and sectionA <= high(TCFileSection).int:
        m.f[TCFileSection(sectionA)] = verbatim
      else:
        var sectionB = CProcSectionNames.find(k)
        if sectionB >= 0 and sectionB <= high(TCProcSection).int:
          m.p[TCProcSection(sectionB)] = verbatim
        else:
          doAssert(false, "ccgmerge: unknown section: " & k)
    else:
      doAssert(false, "ccgmerge: '*/' expected")

proc mergeRequired*(m: BModule): bool =
  for i in cfsHeaders..cfsProcs:
    if m.s[i] != nil:
      #echo "not empty: ", i, " ", m.s[i]
      return true
  for i in TCProcSection:
    if m.initProc.s(i) != nil:
      #echo "not empty: ", i, " ", m.initProc.s[i]
      return true

proc mergeFiles*(cfilename: AbsoluteFile, m: BModule) =
  ## merges the C file with the old version on hard disc.
  var old: TMergeSections
  readMergeSections(cfilename, old)
  # do the merge; old section before new section:
  for i in TCFileSection:
    m.s[i] = old.f[i] & m.s[i]
  for i in TCProcSection:
    m.initProc.s(i) = old.p[i] & m.initProc.s(i)
generated by cgit-pink 1.4.1-2-gfad0 (git 2.36.2.497.gbbea4dcf42) at 2025-02-08 02:15:02 +0000