Memory issues with large amount of roles enabled

Thanks for the help. Here's an outline of the roles being used:

3 Default Drupal Roles - admin, anonymous, and authenticated.
2 Roles that determine basic permissions for accessing private content. All users either have one of these, but not both (although not impossible).
22 Roles that give users editor permissions to the various Library sections on the site. There are 62 users with some combination of these roles.

I would go ahead and just disable the editor roles in Authcache, but they really are the ones that would benefit the most from caching.

Out of the 62 users that have at least one editor role, there are definitely duplicate combinations. What if I only added the combinations that were currently being used instead of having Authcache generate the full amount of combinations? There are probably less than 30 combinations of editor roles + other roles.

Ideally I would want to automatically generate the current combinations from the current active user accounts, and then add that combination into Authcache. This is definitely a little bit of a hacky way to go about this, but changing the way roles are being used on the site isn't really an option at this point.

Thanks again!

So here is my current solution to this problem, admittedly it isn't my ideal solution, but I wanted to get 2.X running as soon as I could to see how the performance was.

The main part of the modification is done in the authcache_authcache_account_properties_info() function in authcache.module. Here's a quick view of the changes:

// Combine remaining roles
$roles = array_keys($roles);
sort($roles);

// Remove editor roles
$basicroles = array(3,21,24);
$editorroles = array_diff($roles, $basicroles);
$roles = array_diff($roles, $editorroles);
sort($roles);

// Add current role combinations
$choices = array_merge($choices, _authcache_get_combo($editorroles));

$choices = array_merge($choices, _authcache_comb($roles));

I'm basically getting any of the editor roles that are enabled in Authcache and then running them through a new function that will return only the used role combinations that are in use.

Here's what the function looks like that is retreiving the combinations:

function _authcache_get_combo($roles) {
  $uids = array();
  $combos = array();
  $authid = array(2);

  // Use $query for readability
  $query = 'SELECT DISTINCT(ur.uid) 
    FROM {users_roles} AS ur
    WHERE ur.rid IN (:rids)';
  $result = db_query($query, array(':rids' => $roles));

  foreach ($result as $row) {
    $uids[] = $row->uid;
  }
  $users = user_load_multiple($uids);
  
  foreach ($users as $user) {
    if ($user->status == 1) {
      $rl = $user->roles;
      $rl = array_keys($rl);
      $rl = array_diff($rl, $authid);
      sort($rl);
      if (!in_array($rl, $combos)) {
        $combos[] = $rl;
      }
    }
  }
  
  return $combos;
}

Here I am getting all of the users that are currently using any of these roles, and then creating a list of role combinations that are being used by the current active users. I did have to remove the authenticated role from the list, but other than that it's pretty straightforward.

With these changes, I am able to add even more editor roles into Drupal and not have to worry about the increase in possible combinations overloading PHP.

So far everything is working great, 2.X is a really nice and the ability to use the Cache Expiration module now makes this an almost perfect setup.

Comments and critiques on the code are welcome and appreciated!