Okay, it's been a while, but I thought I'd finally post about the 2017 Austin Ironman 70.3 race weekend. :-). Like I mentioned in my last post, I felt fairly optimistic -- if anything I was a bit burned out on training.

The big kicker, though, was that the weather was forecast to be 38 degrees race morning, which resulted in a bit of last-minute anxiety, mostly due to the mantra, "Don't do anything different on race day." That is, it is unwise in the extreme to test out new equipment or clothing on race day. Unfortunately, faced with the prospect of a 38 degree swim and bike ride (and the fact that it would warm up quickly), we had to make some last minute adjustments.

The week before the race, I picked up a triathlon jersey that had sleeves, and borrowed some arm warmers from one of my training partners.  Saturday morning, I went for a five mile test ride and realized I needed gloves, which necessitated a trip to Austin Tri-Cyclist, where I was not the only one making such a purchase :-). 

I was still a bit concerned about the swim, but I had a wetsuit, so I figured I'd done all I could do. Still, I was coveting one with sleeves...
I next headed over to the Travis County Expo Center to pick up my swag bag, drop off my bicycle and gear, and check out the transition areas.

Our happy faces before we get out of the car into the cold...

 Next morning, three of us drove out together and arrived in the cold dark of the Travis County Expo. Center at around 5:30. Did I mention that it was cold? Eventually, we got on the bus to take us to the staging area at Walter Long (Decker) Lake. There, we put on wetsuits, met up with our other training partners, and shivered a lot.

Eventually, though, as the sun started to peak above the horizon, we lined up according to our projected swim times and prepared for the start of the race. I was still worried about the swim and the cold -- even though I was wearing socks (to be discarded just before start), my feet were starting to go numb and my arms were not happy either.

But then it was time! I ran into the water and dived in as soon as I could. To my surprise, it was actually pleasant -- the water itself was around 68-72 degrees, so compared to the air temperature, it was balmy.  The only real problem was that fog on the water and the glare of the sun were making it hard to see the buoys. About halfway through the swim I began thinking that the temperature really wasn't bad -- if anything, it was a bit too warm. 

Emerging from the water...

But then I finished the swim and stood and was confronted by the reality of confronting an air temp of around 40 while being soaking wet.  I grabbed my glasses from the special needs table and a nice man helped me get the wetsuit off. (This basically involved lying back on the wet ground, sticking my feet in the air and having him pull. Thank you, sir.). My time was a little slower than I would've liked, but I was fairly happy with it.

I made it to transition, took a big swig of water, swallowed the contents of an energy gel pack, and put on my winter cycling garb. Then I was off!

And it was frickin' cold.

Contemplating that wind chill...

 It was this weird Catch-22 where you want to go as fast as possible (for the race, of course, but also so you warm up), but also kind of are thinking that if you slowed down a touch the wind chill wouldn't be quite so bad.  I ended up spending the next hour shivering until the ambient temperature and I warmed up.
Now, I actually kind of like the bike route -- it's mostly country roads with little traffic, and I rode the route about a half-dozen times in training. The problem with it is that a number of the roads are not exactly well=paved. Bumps and potholes and patches proliferate, especially on Monkey Road. In fact, the dip where it crosses a creek is so bumpy that by the time I got there, there were at least a dozen water bottle scattered on the ground.

There were way too many hills, however :-).

Beyond that, the ride felt fine, although my back began to hurt about halfway through -- I wasn't used to spending that much time in the aero position, so most of the second half of my ride was with hands on the brake hoods. I made sure to stick with my hydration and nutrition plan, so I felt pretty good by the end of it.

Again, my time wasn't quite what I wanted it to be, but I was not displeased.

By the time I finished the ride, it was around noon and fairly warm, so I took the time to change from my sleeved singlet to a sleeveless one (Ironman rules require that you wear a shirt). 

Starting to feel the legs...

The run wasn't as bad as I thought it would be, although there were again too many hills :-).  I was pleased at the number and size of the aid stations -- water, electrolyte drink (Gatorade, iirc), Clif energy gels, Coca-Cola, and Red Bull were all available.  

I was definitely feeling my legs, but my quads didn't feel like they were going to seize up like they had when I did triathlons in the 90s -- all that training paid off, I guess :-). I managed to make it through without slowing to a walk (other than at aid stations, because I can't drink and run at the same time) and ended up with a run time that was comparable to my stand-alone half-marathon times.

At the finish line!

My final time was 5:50:36, which I'm pretty happy about. My goal had been 6:00:00, although I did think that 5:45:00 was not out of the question. :-).

Finisher photo! And medal!

The gang...

All in all, it was a great experience. I got out of my comfort zone, made some terrific friends, learned how to most efficiently change a bike tube, and never once thought, "I can't believe I'm paying to do this." (Okay, maybe once...).

After the race!

Celebrating the next day with Coach Peri!

I just completed my second Ironman 70.3 ("half-Ironman") in Galveston, Texas!

It was different, but not too different than the first. In some ways it was more challenging than Austin, although I did manage to eke out a personal best, so I count myself pleased, although I've identified several areas where I can improve :-).

The Galveston site presented a couple more difficulties than the Austin one, viz., transportation of people and bicycles, as well as housing therefor.  The race site was at Moody Gardens, which has its own resort hotel, which we might have done if we had planned on going on Friday and staying until Monday.  Ultimately, we decided to drive down the morning before the race with our bikes, rent a house via Airbnb, and drive back the evening of the race.

Leaving Austin at 7 AM...

With two bikes on the back, three people (and one bike) in the car, and all our gear, we were pretty packed, but the drive only took about three and a half hours, even accounting for coffee breaks.

We drove directly to Moody Gardens to pick up our race packets and drop off our bikes.  The first thing we discovered when we arrived was that it was cold and rainy and the swim venue (Offats Bayou) was a bit choppy...

Under the triumphal arch the day before the race...

Registration/packet pickup was in a big white tent overlooking the bayou (the same big white tent Moody Gardens had used for a cool dinosaur thing a couple years back).

The white tent with dinosaurs five years ago...

The pickup and registration and dropoff were strangely inefficient: You wait in line at a first table to show your ID and USA Triathlon membership; then you go to a second table to pick up your waiver and other forms. Next, you go to a third table to fill in and sign your waiver and forms, and go to a fourth table to drop off your signed waiver and forms. Thereafter, you go to a fifth table to pick up your wristband and swim cap and bike and helmet stickers; go to a sixth table to pick up your backpack/goodie bag and T-shirt; and finally, go to a seventh table to pick up your timing chip.

Then you exit via the Ironman store and vendor village where you can wait in line to buy stuff.

Inside the big white tent

The course talk was outside and the rain had died down enough so that it wasn't all that unpleasant. Behind us was the paddlewheeler Colonel and a whole lot of choppy water with whitecaps. We were assured that the weather could be better the next day, however. No rain and significantly less wind, although there would be a headwind on the return portion of the bike route.

The paddlewheeler Colonel.

The swim course, with the finish right by the paddlehweeler

The Airbnb was a nice little three-bedroom cottage about five miles from the event site and across from a large cemetery.  It had a complete kitchen that would come in useful later that night when we couldn't get into any of the nearby Italian restaurants without reservations.

The house we rented

Cemetery across street.

Making spaghetti dinner

That evening, we gathered all of our gear and made dinner and looked forward to the race. I went for a three mile run around the nieghborhood to loosen up a bit, and then we made dinner.

I managed to get around five or six hours of sleep and only hit the snooze button once when the alarm went off at 4:30 in the morning. After a couple cups of coffee, a banana, and a bagel, we were off!

The temperature felt good: low fifties, not too much of a breeze. I decided I didn't need gloves, but would take along my arm warmers for the bike just in case. We arrived at Moody Gardens a little after six and discovered we had had to park about a fifteen minute walk from the actual transition area.  A remarkably long line greeted us to enter transition (for body marking), but since we had already done so, we were able to get in with only a brief wait and some judicious weaving through the crowd.

Testing out the wetsuit when I first got it.

There was then the ritual of putting on the wetsuit and pumping the bike tires and then transition closed! (We might have cut the timing a little close).

We then made our way separately to the swim start: they did a wave start by age group. You jump off the pier (see above map), hang around in the water for a couple minutes, and then swim like the wind when you hear the starter's horn.

The water was a nice 72 degrees, about twenty degrees warmer than the outside temperature. The water felt good, although it took a few minutes to get used to the waves and occasional mouthful of salt water. I felt pretty good, though, and noticed myself passing a lot of people.  More importantly, I managed to beat my swim time from last fall's Austin Ironman 70.3.


 Once I was out of the water, the wetsuit strippers were efficient and I had no problem getting to my bike (even without my glasses), stowing my wetsuit and taking off. Because it was relatively warm, I decided not to bother with my sleeves, and I wouldn't have worn gloves even if I had brought them.

The first half of the bike portion was glorious. The temperature was perfect and I had no problems staying in aero position almost the whole way.  Unfortunately, at the turnaround, I was made to realize just how much of a tailwind I had been benefitting from. The rest of the ride felt like I was pulling a mobile home...

Grimacing with miles to go...

Also about that time, the temperature dropped by about ten degrees, and it started to rain. And then my back started to hurt from being in aero position for so long.  In short, the ride back was completely miserable...But I managed to break three hours, which had been my goal.

In addition to the lower back pain, I got a pain between my shoulders, and every time I tried to stand up in the pedals to stretch, my legs felt like they wanted to cramp up.  And my hands were so cold I could barely move them to squeeze my water bottles.

Trying to squeeze out the last drop from my water bottle.

By the time I got back to transition, my hands were so numb that I couldn't operate the clip on my helmet. Putting on my shoes and tying my laces was equally an ordeal. It didn't help that my legs and abs kept cramping up when I bent to tie the laces.  After a ridiculously long transition, I made it onto the run course and my watch died.


But my legs felt good and I enjoyed the run a lot more than I thought I was going to on the return bike. :-). My pacing was a bit off and I came in somewhat slower than I would've liked, but it still felt pretty good.

Victory!

Overall, I came in a couple minutes better than the Austin Ironman 70.3, which I'm pleased with (although I think my run could've gone better).

Mugging with the finisher's medal

Using the R8 recovery roller thing...

All in all, it was a great experience and I'd definitely do the race again. A big thanks to all the organizers, volunteers, sponsors, and first responders who made the event a success!

An analysis of the U.S. Senate's FY 2025 budget request for NASA.

Knowing that you've found signs of life beyond Earth may not be as clear-cut and simple as one might think.

 This is me working out my warband for a Dark age campaign. I can't really get going on it until I have finished my Hobbit armies for an up coming show. So In the meantime time this sketch of the warband will have to do. Out of the hat I got the Black shield Irish.

The rules will be One hour wargames, and it's interesting to see the small size of the warband. Then again it is a skirmish game.

I have to say after the mad month of painting for the Partizan show, my painting mojo is well and truly fried. So I thought I would ease back into things with some gentle building and sculpting.

These figures are a One Hour Wargames Rules campaign set in the age of Arthur. I was picked for the Black shield Irish and so bought a couple of plastic boxes.
 

Skirmishers.

I thought a few Celtic blankets and cloaks wouldn't go a miss. The kits come with some cloaks, but I thought I'd have a go at making my own.
The leader and hero figure from Crusader miniatures. The Druid was a purchase from eBay.
These are a mixture of plastic kits from Gripping Beast and Wargames Atlantic. It's always nice to have more heads etc to create variety in the units.

Here is a small warband of Dark age Irishmen.  They are meant to be the Black shield Irish from the Winter King books. I struggled with just painting black shields as I wanted to paint some designs. I got around this by painting some fancy shields, then painting them black then rubbing off the paint.

This represents the warband painting over their war shields with black. After some heavy campaigning and harsh weather, not to mention dips in the sea, some of the black paint has started to wear off.

There's enough Celtic design underneath to show through.
Not many more to do now, just the druid and four skirmishers.
These are a mix of Crusader, Gripping beast plastic and Wargames Atlantic plastics. They have been very enjoyable to paint too.

 The new rock pools are a perfect setting for Raiding Black shields.

Table of Contents

1. Thread Local storage exhausted
2. The layer of indirection
3. I can fix her
4. Let's write some tests!
5. Summary

Thread Local storage exhausted

In the last post I've described a technique to use dynamic variables by value instead of the name by utilizing the operator PROGV. Apparently it works fine on all Common Lisp implementations I've tried except from SBCL, where the number of thread local variables is by default limited to something below 4000. To add salt to the injury, these variables are not garbage collected.

Try the following code to crash into LDB:

(defun foo ()
  (loop for i from 0 below 4096 do
    (when (zerop (mod i 100))
      (print i))
    (progv (list (gensym)) (list 42)
      (values))))
(foo)

This renders our new technique not very practical given SBCL popularity. We need to either abandon the idea or come up with a workaround.

The layer of indirection

Luckily for us we've already introduced a layer of indirection. Operators to access dynamic variables are called DLET, DSET and DREF. This means, that it is enough to provide a kludge implementation for SBCL with minimal changes to the remaining code.

The old code works the same as previously except that instead of SYMBOL-VALUE we use the accessor DYNAMIC-VARIABLE-VALUE, and the old call to PROGV is now DYNAMIC-VARIABLE-PROGV. Moreover DYNAMIC-EFFECTIVE-SLOT used functions BOUNDP and MAKUNBOUND, so we replace these with DYNAMIC-VARIABLE-BOUND-P and DYNAMIC-VARIABLE-MAKUNBOUND. To abstract away things further we also introduce the constructor MAKE-DYNAMIC-VARIABLE

(defpackage "EU.TURTLEWARE.BLOG/DLET"
  (:local-nicknames ("MOP" #+closer-mop "C2MOP"
                           #+(and (not closer-mop) ecl) "MOP"
                           #+(and (not closer-mop) ccl) "CCL"
                           #+(and (not closer-mop) sbcl) "SB-MOP"))
  (:use "CL"))
(in-package "EU.TURTLEWARE.BLOG/DLET")

(eval-when (:compile-toplevel :execute :load-toplevel)
  (unless (member :bordeaux-threads *features*)
    (error "Please load BORDEAUX-THREADS."))
  (when (member :sbcl *features*)
    (unless (member :fake-progv-kludge *features*)
      (format t "~&;; Using FAKE-PROGV-KLUDGE for SBCL.~%")
      (push :fake-progv-kludge *features*))))

(defmacro dlet (bindings &body body)
  (flet ((pred (binding)
           (and (listp binding) (= 2 (length binding)))))
    (unless (every #'pred bindings)
      (error "DLET: bindings must be lists of two values.~%~
                Invalid bindings:~%~{ ~s~%~}" (remove-if #'pred bindings))))
  (loop for (var val) in bindings
        collect var into vars
        collect val into vals
        finally (return `(dynamic-variable-progv (list ,@vars) (list ,@vals)
                           ,@body))))

(defmacro dset (&rest pairs)
  `(setf ,@(loop for (var val) on pairs by #'cddr
                 collect `(dref ,var)
                 collect val)))

(defmacro dref (variable)
  `(dynamic-variable-value ,variable))

;;; ...

(defmethod mop:slot-boundp-using-class
    ((class standard-class)
     object
     (slotd dynamic-effective-slot))
  (dynamic-variable-bound-p (slot-dvar object slotd)))

(defmethod mop:slot-makunbound-using-class
    ((class standard-class)
     object
     (slotd dynamic-effective-slot))
  (dynamic-variable-makunbound (slot-dvar object slotd)))

With these in place we can change the portable implementation to conform.

#-fake-progv-kludge
(progn
  (defun make-dynamic-variable ()
    (gensym))

  (defun dynamic-variable-value (variable)
    (symbol-value variable))

  (defun (setf dynamic-variable-value) (value variable)
    (setf (symbol-value variable) value))

  (defun dynamic-variable-bound-p (variable)
    (boundp variable))

  (defun dynamic-variable-makunbound (variable)
    (makunbound variable))

  (defmacro dynamic-variable-progv (vars vals &body body)
    `(progv ,vars ,vals ,@body)))

I can fix her

The implementation for SBCL will mediate access to the dynamic variable value with a synchronized hash table with weak keys. The current process is the key of the hash table and the list of bindings is the value of the hash table. For compatibility between implementations the top level value of the symbol will be shared.

The variable +FAKE-UNBOUND+ is the marker that signifies, that the variable has no value. When the list of bindings is EQ to +CELL-UNBOUND+, then it means that we should use the global value. We add new bindings by pushing to it.

#+fake-progv-kludge
(progn
  (defvar +fake-unbound+ 'unbound)
  (defvar +cell-unbound+ '(no-binding))

  (defclass dynamic-variable ()
    ((tls-table
      :initform (make-hash-table :synchronized t :weakness :key)
      :reader dynamic-variable-tls-table)
     (top-value
      :initform +fake-unbound+
      :accessor dynamic-variable-top-value)))

  (defun make-dynamic-variable ()
    (make-instance 'dynamic-variable))

  (defun dynamic-variable-bindings (dvar)
    (let ((process (bt:current-thread))
          (tls-table (dynamic-variable-tls-table dvar)))
      (gethash process tls-table +cell-unbound+)))

  (defun (setf dynamic-variable-bindings) (value dvar)
    (let ((process (bt:current-thread))
          (tls-table (dynamic-variable-tls-table dvar)))
      (setf (gethash process tls-table +cell-unbound+) value))))

We define two readers for the variable value - one that simply reads the value, and the other that signals an error if the variable is unbound. Writer for its value either replaces the current binding, or if the value cell is unbound, then we modify the top-level symbol value. We use the value +FAKE-UNBOUND+ to check whether the variable is bound and to make it unbound.

#+fake-progv-kludge
(progn
  (defun %dynamic-variable-value (dvar)
    (let ((tls-binds (dynamic-variable-bindings dvar)))
      (if (eq tls-binds +cell-unbound+)
          (dynamic-variable-top-value dvar)
          (car tls-binds))))

  (defun dynamic-variable-value (dvar)
    (let ((tls-value (%dynamic-variable-value dvar)))
      (when (eq tls-value +fake-unbound+)
        (error 'unbound-variable :name "(unnamed)"))
      tls-value))

  (defun (setf dynamic-variable-value) (value dvar)
    (let ((tls-binds (dynamic-variable-bindings dvar)))
      (if (eq tls-binds +cell-unbound+)
          (setf (dynamic-variable-top-value dvar) value)
          (setf (car tls-binds) value))))

  (defun dynamic-variable-bound-p (dvar)
    (not (eq +fake-unbound+ (%dynamic-variable-value dvar))))

  (defun dynamic-variable-makunbound (dvar)
    (setf (dynamic-variable-value dvar) +fake-unbound+)))

Finally we define the operator to dynamically bind variables that behaves similar to PROGV. Note that we PUSH and POP from the thread-local hash table DYNAMIC-VARIABLE-BINDINGS, so no synchronization is necessary.

#+fake-progv-kludge
(defmacro dynamic-variable-progv (vars vals &body body)
  (let ((svars (gensym))
        (svals (gensym))
        (var (gensym))
        (val (gensym)))
    `(let ((,svars ,vars))
       (loop for ,svals = ,vals then (rest ,svals)
             for ,var in ,svars
             for ,val = (if ,svals (car ,svals) +fake-unbound+)
             do (push ,val (dynamic-variable-bindings ,var)))
       (unwind-protect (progn ,@body)
         (loop for ,var in ,svars
               do (pop (dynamic-variable-bindings ,var)))))))

Let's write some tests!

But of course, we are going to also write a test framework. It's short, I promise. As a bonus point the API is compatibile with fiveam, so it is possible to drop tests as is in the appropriate test suite.

(defvar *all-tests* '())

(defun run-tests ()
  (dolist (test (reverse *all-tests*))
    (format *debug-io* "Test ~a... " test)
    (handler-case (funcall test)
      (serious-condition (c)
        (format *debug-io* "Failed: ~a~%" c))
      (:no-error (&rest args)
        (declare (ignore args))
        (format *debug-io* "Passed.~%")))))

(defmacro test (name &body body)
  `(progn
     (pushnew ',name *all-tests*)
     (defun ,name () ,@body)))

(defmacro is (form)
  `(assert ,form))

(defmacro pass ())

(defmacro signals (condition form)
  `(is (block nil
         (handler-case ,form
           (,condition () (return t)))
         nil)))

(defmacro finishes (form)
  `(is (handler-case ,form
         (serious-condition (c)
           (declare (ignore c))
           nil)
         (:no-error (&rest args)
           (declare (ignore args))
           t))))

Now let's get to tests. First we'll test our metaclass:

(defclass dynamic-let.test-class ()
  ((slot1 :initarg :slot1 :dynamic nil :accessor slot1)
   (slot2 :initarg :slot2 :dynamic t   :accessor slot2)
   (slot3 :initarg :slot3              :accessor slot3))
  (:metaclass class-with-dynamic-slots))

(defparameter *dynamic-let.test-instance-1*
  (make-instance 'dynamic-let.test-class
                 :slot1 :a :slot2 :b :slot3 :c))

(defparameter *dynamic-let.test-instance-2*
  (make-instance 'dynamic-let.test-class
                 :slot1 :x :slot2 :y :slot3 :z))

(test dynamic-let.1
  (let ((o1 *dynamic-let.test-instance-1*)
        (o2 *dynamic-let.test-instance-2*))
    (with-slots (slot1 slot2 slot3) o1
      (is (eq :a slot1))
      (is (eq :b slot2))
      (is (eq :c slot3)))
    (with-slots (slot1 slot2 slot3) o2
      (is (eq :x slot1))
      (is (eq :y slot2))
      (is (eq :z slot3)))))

(test dynamic-let.2
  (let ((o1 *dynamic-let.test-instance-1*)
        (o2 *dynamic-let.test-instance-2*))
    (signals error (slot-dlet (((o1 'slot1) 1)) nil))
    (slot-dlet (((o1 'slot2) :k))
      (is (eq :k (slot-value o1 'slot2)))
      (is (eq :y (slot-value o2 'slot2))))))

(test dynamic-let.3
  (let ((o1 *dynamic-let.test-instance-1*)
        (exit nil)
        (fail nil))
    (flet ((make-runner (values)
             (lambda ()
               (slot-dlet (((o1 'slot2) :start))
                 (let ((value (slot2 o1)))
                   (unless (eq value :start)
                     (setf fail value)))
                 (loop until (eq exit t) do
                   (setf (slot2 o1) (elt values (random (length values))))
                   (let ((value (slot2 o1)))
                     (unless (member value values)
                       (setf fail value)
                       (setf exit t))))))))
      (let ((r1 (bt:make-thread (make-runner '(:k1 :k2))))
            (r2 (bt:make-thread (make-runner '(:k3 :k4))))
            (r3 (bt:make-thread (make-runner '(:k5 :k6)))))
        (sleep .1)
        (setf exit t)
        (map nil #'bt:join-thread (list r1 r2 r3))
        (is (eq (slot2 o1) :b))
        (is (null fail))))))

Then let's test the dynamic variable itself:

(test dynamic-let.4
  "Test basic dvar operators."
  (let ((dvar (make-dynamic-variable)))
    (is (eql 42 (dset dvar 42)))
    (is (eql 42 (dref dvar)))
    (ignore-errors
     (dlet ((dvar :x))
       (is (eql :x (dref dvar)))
       (error "foo")))
    (is (eql 42 (dref dvar)))))

(test dynamic-let.5
  "Test bound-p operator."
  (let ((dvar (make-dynamic-variable)))
    (is (not (dynamic-variable-bound-p dvar)))
    (dset dvar 15)
    (is (dynamic-variable-bound-p dvar))
    (dynamic-variable-makunbound dvar)
    (is (not (dynamic-variable-bound-p dvar)))))

(test dynamic-let.6
  "Test makunbound operator."
  (let ((dvar (make-dynamic-variable)))
    (dset dvar t)
    (is (dynamic-variable-bound-p dvar))
    (finishes (dynamic-variable-makunbound dvar))
    (is (not (dynamic-variable-bound-p dvar)))))

(test dynamic-let.7
  "Test locally bound-p operator."
  (let ((dvar (make-dynamic-variable)))
    (is (not (dynamic-variable-bound-p dvar)))
    (dlet ((dvar 15))
      (is (dynamic-variable-bound-p dvar)))
    (is (not (dynamic-variable-bound-p dvar)))))

(test dynamic-let.8
  "Test locally unbound-p operator."
  (let ((dvar (make-dynamic-variable)))
    (dset dvar t)
    (is (dynamic-variable-bound-p dvar))
    (dlet ((dvar nil))
      (is (dynamic-variable-bound-p dvar))
      (finishes (dynamic-variable-makunbound dvar))
      (is (not (dynamic-variable-bound-p dvar))))
    (is (dynamic-variable-bound-p dvar))))

(test dynamic-let.9
  "Stress test the implementation (see :FAKE-PROGV-KLUDGE)."
  (finishes                              ; at the same time
    (let ((dvars (loop repeat 4096 collect (make-dynamic-variable))))
      ;; ensure tls variable
      (loop for v in dvars do
        (dlet ((v 1))))
      (loop for i from 0 below 4096
            for r = (random 4096)
            for v1 in dvars
            for v2 = (elt dvars r) do
              (when (zerop (mod i 64))
                (pass))
              (dlet ((v1 42)
                     (v2 43))
                (values))))))

(test dynamic-let.0
  "Stress test the implementation (see :FAKE-PROGV-KLUDGE)."
  (finishes                             ; can be gc-ed
    (loop for i from 0 below 4096 do
      (when (zerop (mod i 64))
        (pass))
      (dlet (((make-dynamic-variable) 42))
        (values)))))

All that is left is to test both dynamic variable implementations:

BLOG/DLET> (lisp-implementation-type)
"ECL"
BLOG/DLET> (run-tests)
Test DYNAMIC-LET.1... Passed.
Test DYNAMIC-LET.2... Passed.
Test DYNAMIC-LET.3... Passed.
Test DYNAMIC-LET.4... Passed.
Test DYNAMIC-LET.5... Passed.
Test DYNAMIC-LET.6... Passed.
Test DYNAMIC-LET.7... Passed.
Test DYNAMIC-LET.8... Passed.
Test DYNAMIC-LET.9... Passed.
Test DYNAMIC-LET.0... Passed.
NIL

And with the kludge:

BLOG/DLET> (lisp-implementation-type)
"SBCL"
BLOG/DLET> (run-tests)
Test DYNAMIC-LET.1... Passed.
Test DYNAMIC-LET.2... Passed.
Test DYNAMIC-LET.3... Passed.
Test DYNAMIC-LET.4... Passed.
Test DYNAMIC-LET.5... Passed.
Test DYNAMIC-LET.6... Passed.
Test DYNAMIC-LET.7... Passed.
Test DYNAMIC-LET.8... Passed.
Test DYNAMIC-LET.9... Passed.
Test DYNAMIC-LET.0... Passed.
NIL

Summary

In this post we've made our implementation to work on SBCL even when there are more than a few thousand dynamic variables. We've also added a simple test suite that checks the basic behavior.

As it often happens, after achieving some goal we get greedy and achieve more. That's the case here as well. In the next (and the last) post in this series I'll explore the idea of adding truly thread-local variables without a shared global value. This will be useful for lazily creating context on threads that are outside of our control. We'll also generalize the implementation so it is possible to subclass and implement ones own flavor of a dynamic variable.

1. Why Virat Kohli, Jasprit Bumrah were missing from Perth nets; India ramp up privacy amid Manchester United-like security  Hindustan Times
2. Virat Kohli in focus: Intense net session begins for upcoming Test series against Australia  The Times of India
3. Virat Kohli in Australia for BGT: A timeline  India Today
4. Black veil of secrecy: India begin training in privacy in Perth  ESPNcricinfo
5. India to play intra-squad warm-up match at WACA on Friday ahead of Australia Tests but BCCI denies public viewing  Hindustan Times

1. Melania Trump's 'I am the most bullied person' video viral as she 'rejects' Jill Biden's tea invite  The Times of India
2. Melania Trump declines invite to meet Jill Biden over Mar-a-Lago raids when FBI ’snooped through her wardrobe’  Mint
3. Jimmy Kimmel again mocks Donald Trump for Melania's ‘interesting’ decision to…  Hindustan Times
4. Biden Invites Trump To White House, But Why Is Melania Refusing To Go?  News18
5. Melania Trump To Skip White House Meeting With Jill Biden: Report  NDTV

1. 3 Children, 3 Women Missing After 10 Suspected Kuki Militants Killed In Encounter In Manipur's Jiribam  NDTV
2. Manipur on boil: 2 more bodies found, 6 missing  The Times of India
3. Additional paramilitary forces rushed to Manipur amid spike in ethnic violence  Hindustan Times
4. Letters to The Editor — November 13, 2024  The Hindu
5. 2 men found dead, 6 of family missing day after militants killed in Manipur  India Today

Full Article