Eloquent performance: improve caching in HasAttributes::getCastType() and HasAttributes::isEncryptedCastable()

[thomas-0816]

Laravel Version

12.28

PHP Version

8.4.12

Database Driver & Version

mariadb 10.11.13

Description

I profiled a long running job with spx and got:

*** SPX Report ***

Global stats:

  Called functions    :   436.7M
  Distinct functions  :     3.1K

  Wall time           :   53.16s
  ZE memory usage     :  237.5MB

Flat profile:

 Wall time           | ZE memory usage     |
 Inc.     | *Exc.    | Inc.     | Exc.     | Called   | Function
----------+----------+----------+----------+----------+----------
   12.80s |    3.52s |     376B |  -42.8GB |    25.7M | Illuminate\Database\Eloquent\Model::getCastType
   15.63s |    1.85s |     376B |       0B |     8.3M | Illuminate\Database\Eloquent\Model::castAttribute
   12.21s |  925.6ms |       0B |       0B |     2.7M | Illuminate\Database\Eloquent\Model::originalIsEquivalent
   22.95s |  813.9ms |    9.6KB |       0B |     6.5M | Illuminate\Database\Eloquent\Model::getAttributeValue
    8.41s |  760.7ms |  203.5MB |  203.5MB |     1.1M | Illuminate\Database\Eloquent\Model::setAttribute
    3.98s |  441.6ms |      80B |       0B |   492.4K | Illuminate\Support\Collection::{closure:Illuminate\Support\Traits\EnumeratesValues::operatorForWhere():1101}
    3.46s |  340.8ms |       0B |       0B |     2.3M | Illuminate\Database\Eloquent\Model::isDateAttribute
    5.90s |  273.9ms |   43.5MB |   -1.0MB |    25.7K | Illuminate\Support\Collection::groupBy

then I changed the HasAttributes::getCastType() from:

    protected function getCastType($key)
    {
        $castType = $this->getCasts()[$key];

        if (isset(static::$castTypeCache[$castType])) {
            return static::$castTypeCache[$castType];
        }

        if ($this->isCustomDateTimeCast($castType)) {
            $convertedCastType = 'custom_datetime';
        } elseif ($this->isImmutableCustomDateTimeCast($castType)) {
            $convertedCastType = 'immutable_custom_datetime';
        } elseif ($this->isDecimalCast($castType)) {
            $convertedCastType = 'decimal';
        } elseif (class_exists($castType)) {
            $convertedCastType = $castType;
        } else {
            $convertedCastType = trim(strtolower($castType));
        }

        return static::$castTypeCache[$castType] = $convertedCastType;
    }

to:

    protected function getCastType($key)
    {
        if (isset(static::$castTypeCache[static::class][$key])) {
            return static::$castTypeCache[static::class][$key];
        }

        $castType = $this->getCasts()[$key];

        if ($this->isCustomDateTimeCast($castType)) {
            $convertedCastType = 'custom_datetime';
        } elseif ($this->isImmutableCustomDateTimeCast($castType)) {
            $convertedCastType = 'immutable_custom_datetime';
        } elseif ($this->isDecimalCast($castType)) {
            $convertedCastType = 'decimal';
        } elseif (class_exists($castType)) {
            $convertedCastType = $castType;
        } else {
            $convertedCastType = trim(strtolower($castType));
        }

        return static::$castTypeCache[static::class][$key] = $convertedCastType;
    }

The runtime of the job went from 21.7s to 17.7s (without spx).

Then I changed HasAttributes::isEncryptedCastable() from:

    protected function isEncryptedCastable($key)
    {
        return $this->hasCast($key, ['encrypted', 'encrypted:array', 'encrypted:collection', 'encrypted:json', 'encrypted:object']);
    }

to:

    protected static $encryptedCastableCache = [];

    protected function isEncryptedCastable($key)
    {
        if (isset(static::$encryptedCastableCache[static::class][$key])) {
            return static::$encryptedCastableCache[static::class][$key];
        }

        return static::$encryptedCastableCache[static::class][$key] = $this->hasCast($key, ['encrypted', 'encrypted:array', 'encrypted:collection', 'encrypted:json', 'encrypted:object']);
    }

The runtime of the job went from 17.7s to 15.1s (without spx). So a total of 30% faster.

What do you think about these changes?

Note: I can't provide a PR for this, but you and the community are free to create a PR for this.

Steps To Reproduce

Run a script using Eloquent with many Model instances.

[macropay-solutions]

Hi,
We don't use casts because we know they are just a brake for the execution but still, after your investigation it seems we are still affected by them just being a feature in the framework.

1. Can you confirm that this happens even if you don't use casts?

2. Also there is the issue of octane AND worker in daemon mode. Can you confirm that your changes are not affecting them because of the static?

3. And last, do you know the memory increase generated by these 2 static caches in long time running scripts?

[thomas-0816]

1. yes, to disable casts, $casts needs to be an empty array and $incrementing needs to be false.

2. from my tests, the change is ok for queue workers, I'm not using octane.

3. in my tests, memory_get_peak_usage(true) did not change after changing trait HasAttributes.

[thomas-0816]

I changed the code a bit to nested array $...Cache[static::class][$key] which performs even better.

The mutator caches in HasAttributes use $...Cache[get_class($this)][$key], but I think static::class should provide better performance with same functionality.

[macropay-solutions]

Interesting how this was missed when it was first implemented. The fact that the parent protected static is shared for all child models. Can't this lead to issues if in the same PID one method sets the cache for a key to something and for another model the same key is casted to another type?

Model 1

'col' needs cast fom json to array

Model 2
'col' needs cast to decimal

UPDATE:
Sorry, the above is wrong.

The initial cache holds in it ['decimal'=> 'decimal'] for any model.
The key is involved only in getting the cast not in the cache.

@thomas-0816 so you putting in there also the FQN of the model just increases the static variable needed memory. What is the advantage? The key was not part of the cache and in your versions it is.

The speed gain must be attributed to
$this->getCasts()[$key]
not being called on each function call coupled with the other change from isEncryptedCastable

[thomas-0816]

What is the advantage?

Better performance for getCastType() and isEncryptedCastable(), resulting in better performance for castAttribute().

[macropay-solutions]

@thomas-0816 can you please try this:

    protected function getCastType($key)
    {
        static $test;
        $castType = ($test[static::class] ??= $this->getCasts())[$key];

        if (isset(static::$castTypeCache[$castType])) {
            return static::$castTypeCache[$castType];
        }

        if ($this->isCustomDateTimeCast($castType)) {
            $convertedCastType = 'custom_datetime';
        } elseif ($this->isImmutableCustomDateTimeCast($castType)) {
            $convertedCastType = 'immutable_custom_datetime';
        } elseif ($this->isDecimalCast($castType)) {
            $convertedCastType = 'decimal';
        } elseif (class_exists($castType)) {
            $convertedCastType = $castType;
        } else {
            $convertedCastType = trim(strtolower($castType));
        }

        return static::$castTypeCache[$castType] = $convertedCastType;
    }

And if this is faster then you can try moving the caching in the getCasts function by static::class to see the results. That should improve also other functions that call getCasts function.

[thomas-0816]

Yes caching getCasts() also makes an improvement, great!

From the previous 15.1s it gets to 12.0s. Total from 21.7 it gives 44% better performance.

Caching isDateAttribute() gets 11.8s.

Summary of changes I made:

    protected static $getCastTypeCache = [];

    protected function getCastType($key)
    {
        if (isset(static::$getCastTypeCache[static::class][$key])) {
            return static::$getCastTypeCache[static::class][$key];
        }

        $castType = $this->getCasts()[$key];

        if ($this->isCustomDateTimeCast($castType)) {
            $convertedCastType = 'custom_datetime';
        } elseif ($this->isImmutableCustomDateTimeCast($castType)) {
            $convertedCastType = 'immutable_custom_datetime';
        } elseif ($this->isDecimalCast($castType)) {
            $convertedCastType = 'decimal';
        } elseif (class_exists($castType)) {
            $convertedCastType = $castType;
        } else {
            $convertedCastType = trim(strtolower($castType));
        }

        return static::$getCastTypeCache[static::class][$key] = $convertedCastType;
    }
    
    protected static $getCastsCache = [];

    public function getCasts()
    {
        if (isset(static::$getCastsCache[static::class])) {
            return static::$getCastsCache[static::class];
        }

        if ($this->getIncrementing()) {
            return static::$getCastsCache[static::class] = array_merge([$this->getKeyName() => $this->getKeyType()], $this->casts);
        }

        return static::$getCastsCache[static::class] = $this->casts;
    }

    protected static $isEncryptedCastableCache = [];

    protected function isEncryptedCastable($key)
    {
        if (isset(static::$isEncryptedCastableCache[static::class][$key])) {
            return static::$isEncryptedCastableCache[static::class][$key];
        }

        return static::$isEncryptedCastableCache[static::class][$key] = $this->hasCast($key, ['encrypted', 'encrypted:array', 'encrypted:collection', 'encrypted:json', 'encrypted:object']);
    }

    protected static $isDateAttributeCache = [];

    protected function isDateAttribute($key)
    {
        if (isset(static::$isDateAttributeCache[static::class][$key])) {
            return static::$isDateAttributeCache[static::class][$key];
        }

        return static::$isDateAttributeCache[static::class][$key] = (in_array($key, $this->getDates(), true) ||
            $this->isDateCastable($key));
    }

[thomas-0816]

Another performance improvement might come from using typed properties and property hooks, but I'm not sure what's the current status with Eloquent on this.

[macropay-solutions]

Another performance improvement might come from using typed properties and property hooks, but I'm not sure what's the current status with Eloquent on this.

The active record does not work well with attributes(columns) as model properties. Also property hooks are not yet mature enough because the array does not fully work. You can read more in the php documentation about it.