If records are never deleted and you're okay with a few misses, use ExtentSizeFast, if you need the fastest precise runtime implementation use ExtentSize, in you need better compile speed and don't care about runtime speed use GetExtentSize.

/// w ##class(Utils.Persistent).GetGlobal("Utils.Persistent")
ClassMethod GetDataGlobal(Class As %Dictionary.CacheClassname) As %String
{
    Quit:'$$$comClassDefined(Class) ""
    Set Strategy = $$$comClassKeyGet(Class, $$$cCLASSstoragestrategy)
    Quit $$$defMemberKeyGet(Class, $$$cCLASSstorage, Strategy, $$$cSDEFdatalocation)
}

/// w ##class(Utils.Persistent).ExtentSizeFast("Utils.Persistent")
ClassMethod ExtentSizeFast(Class As %Dictionary.CacheClassname) As %String [ CodeMode = expression ]
{
$Get(@..GetDataGlobal(Class), 0)
}


/// w ##class(Utils.Persistent).GetExtentSize("Utils.Persistent")
ClassMethod GetExtentSize(Class As %String) As %Integer
{
    Set Global = ..GetDataGlobal(Class)
    Quit:Global="" 0
   
    Set Id = $Order(@Global@(""))
    Set Count = 0
    While Id '= "" {
        Set Id = $Order(@Global@(Id))
        Set Count = Count + 1
    }
    Quit Count
}

ClassMethod ExtentSize() As %Integer [ CodeMode = objectgenerator ]
{
    set Strategy = $$$comClassKeyGet(%classname, $$$cCLASSstoragestrategy)
    set Global = $$$defMemberKeyGet(%classname, $$$cCLASSstorage, Strategy, $$$cSDEFdatalocation)
    Do %code.WriteLine(" Set Id = $Order(" _ Global _ "(""""))")
    Do %code.WriteLine(" Set Count = 0")
    Do %code.WriteLine(" While Id '= """" {")
    Do %code.WriteLine("     Set Id = $Order(" _ Global _ "(Id))")
    Do %code.WriteLine("     Set Count = Count + 1")
    Do %code.WriteLine(" }")
    Do %code.WriteLine(" Quit Count")
    Quit $$$OK
}

set user = $username
set role = "MyOperation"
set sc = ##class(EnsLib.Workflow.UserDefinition).CreateUser(user)
set sc = ##class(EnsLib.Workflow.RoleDefinition).CreateRole(role)
set sc = ##class(EnsLib.Workflow.RoleDefinition).AddUserToRole(role, user)

Export role/user globals as xml.

$STORAGE is a special variable which contains the number of bytes available for a current process. After it hits zero you get STORE error. You can profile your code to see which part leaks memory. Small example:

write $STORAGE
>268326112
set i=1
write $STORAGE
>268326104
kill i
write $STORAGE
>268326112

Check that:

• $storage before and after EvaluateClone call is the same
• $storage on each loop cycle is the same

Another approach is throwing/catching and logging an exception and checking what's available in each frame.

do clone.Children.RemoveAt(key) // update clone

RemoveAt returns oref, maybe you need to kill it.

I'm wondering if IS has a java-like garbage collector (as in "the object is automatically destroyed"), and if so, is this keeping up with the clone construction and killing, over a 200k+ loop? Is it an immediate thing, or is there a garbage collector crawling around looking for un-referenced objects?

InterSystems products have automatic garbage collector. I'm not sure on the specifics. Calling @Dan Pasco.

You can use Java Gateway and this project.

On a first overview this looks like a container specification with standard crypto algorithms. So you can definitely implement it in InterSystems IRIS. I have done Xades implementation for InterSystems IRIS and it's doable (500 sloc total).

There's a workaround for import:

  Set dynObj = {}.%FromJSON(jsonStream)
  Set hexStream = dynObj.%Get("hex_stream",,"stream")
  Set base64Stream = dynObj.%Get("base64_stream",,"stream")
 
  Set dynObj."hex_stream" = ""
  Set dynObj."base64_stream" = ""
  Do dynObj.%Remove("hex_stream")
  Do dynObj.%Remove("base64_stream")
 
  Set newObject = ..%New()
  Set newObject.HexStream = hexStream
  Set newObject.Base64Stream = base64Stream
 
  Set tSC = newObject.%JSONImport(dynObj)