sys/src/memoryalc_pool.c

Go to the documentation of this file.

// _Id: memoryalc_pool.c,v 1.6 2007-08-10 11:25:30 roart Exp $
// _Locker:  $

// Author. Roar Thronæs.

#include <linux/config.h>
#include <linux/compiler.h>
#include <linux/init.h>
#include <linux/mm.h>

#include<irpdef.h>
#include<npool_data.h>
#include<ssdef.h>
#include<system_data_cells.h>
#include <exe_routines.h>
#include <misc_routines.h>
#include <mmg_routines.h>
#include <internals.h>
#include <ipldef.h>

struct _myhead {
  struct _myhead * hd_l_flink;
  long hd_l_seq;
};

void exe_reclaim_pool_aggressive(void * pool);

// this has its parallell in exe_alonpagvar
int exe_allocate_pool(int requestsize, int pooltype, int alignment, unsigned int * allocatedsize, void ** returnblock) {
  int reqsize=requestsize;
  unsigned int * alosize_p=allocatedsize;
  void ** pool_p=returnblock;
  int sts=SS__NORMAL;

  // extra from alononpaged
  if (reqsize&63)
    reqsize=((reqsize>>6)+1)<<6; // mm book said something about align 64

  *alosize_p=reqsize;

  struct _npool_data * pooldata = exe_gs_bap_npool;
  struct _lsthds * lsthd = pooldata->npool_ar_lsthds;
  struct _myhead * array = &lsthd->lsthds_q_listheads;

  if (reqsize<=8192) {
    *pool_p = exe_lal_remove_first(&array[reqsize>>6]);
    if (*pool_p) {
      check_packet(*pool_p,reqsize,0);
#if 0
      poison_packet(*pool_p,reqsize,0);
#endif
    }
  } 
  // extra end

  if (*pool_p) 
    return sts;

  int ipl = vmslock(&SPIN_POOL, IPL__POOL);
  sts=exe_allocate(reqsize , &exe$gq_bap_variable, 0 , alosize_p, pool_p);
  vmsunlock(&SPIN_POOL, ipl);

  // unlock pool

  if (sts==SS__NORMAL)
    return sts;

#if 0
  struct _npool_data * pooldata = exe_gs_bap_npool;
  struct _lsthds * lsthd = pooldata->npool_ar_lsthds;
  void * array = &lsthd->lsthds_q_listheads;
#endif

  exe_reclaim_pool_aggressive(exe$gs_bap_npool);
  ipl = vmslock(&SPIN_POOL, IPL__POOL);
  sts=exe_allocate(reqsize , &exe$gq_bap_variable, 0 , alosize_p, pool_p);
  vmsunlock(&SPIN_POOL, ipl);

  if (sts==SS__NORMAL)
    return sts;

  sts=exe_extendpool(exe$gs_bap_npool);
  if (sts==SS__NORMAL) {
    int ipl = vmslock(&SPIN_POOL, IPL__POOL);
    sts=exe_allocate(reqsize , &exe$gq_bap_variable, 0 , alosize_p, pool_p);
    vmsunlock(&SPIN_POOL, ipl);
  }

  if (sts==SS__NORMAL)
    return sts;

  sts=exe_flushlists(exe$gs_bap_npool, reqsize);

  if (sts==SS__NORMAL) {
    int ipl = vmslock(&SPIN_POOL, IPL__POOL);
    sts=exe_allocate(reqsize , &exe$gq_bap_variable, 0 , alosize_p, pool_p);
    vmsunlock(&SPIN_POOL, ipl);
  }

  return sts;
}

void exe_deallocate_pool(void * returnblock, int pooltype, int size) {
  void * pool=returnblock;
  if (size&63)
    size=((size>>6)+1)<<6; // mm book said something about align 64

  if (size==0 || (size&63))
    panic("size size %x\n",size);

  struct _npool_data * pooldata = exe_gs_bap_npool;
  struct _lsthds * lsthd = pooldata->npool_ar_lsthds;
  struct _myhead * array = &lsthd->lsthds_q_listheads;

  if (size<=8192) {
    poison_packet(pool,size,1);
    exe_lal_insert_first(pool, &array[size>>6]);
  } else {
    int ipl = vmslock(&SPIN_POOL, IPL__POOL);
    int sts=exe_deallocate(pool, exe$gq_bap_variable, size);
    vmsunlock(&SPIN_POOL, ipl);
  }
  return SS__NORMAL;
}

exe_extend_npp(void * pool) {
  // 4 axppages is 8 386pages
  printk("exe_extendpool/npp not yet implemented (not so difficult?\n");
  return SS__INSFMEM;
}

exe_extendpool(void * pool) {
  return exe_extend_npp(pool);
}

static int trim=1;

exe_trim_pool_list(int percentage, void * listhead, void * basepool) {
  
  struct _myhead * hd = listhead;
  int cut;
  cut = hd[trim].hd_l_seq * percentage / 100;
  for (; cut; cut--) {
    void * ret = exe_lal_remove_first(&hd[trim]);
    if (ret) {
      int ipl = vmslock(&SPIN_POOL, IPL__POOL);
      exe_deallocate(ret, basepool, 64*trim);
      vmsunlock(&SPIN_POOL, ipl);
    }
  }
  cut = hd[64+trim].hd_l_seq * (100 - percentage) / 100;
  for (; cut; cut--) {
    void * ret = exe_lal_remove_first(&hd[64+trim]);
    if (ret) {
      int ipl = vmslock(&SPIN_POOL, IPL__POOL);
      exe_deallocate(ret, basepool, 64*(64+trim));
      vmsunlock(&SPIN_POOL, ipl);
    }
  }
  trim++;
  if (trim>64)
    trim=1;
}

void exe_reclaim_pool_aggressive(void * pool) {
  struct _npool_data * pooldata = pool;
  struct _lsthds * lsthd = pooldata->npool_ar_lsthds;
  void * array = &lsthd->lsthds_q_listheads;
  void * listhead=array;
  void * basepool=lsthd->lsthds_l_variablelist_unused;
  exe_trim_pool_list(50,listhead, basepool);
}

void exe_reclaim_pool_gentle(void * pool) {
  printk("timer exe_reclaim_pool_gentle %x\n",trim);
  struct _npool_data * pooldata = pool;
  struct _lsthds * lsthd = pooldata->npool_ar_lsthds;
  void * array = &lsthd->lsthds_q_listheads;
  void * listhead=array;
  void * basepool=lsthd->lsthds_l_variablelist_unused;
  exe_trim_pool_list(85,listhead, basepool);
  signed long long time=-10000000*60;
  exe_setimr(0, &time, exe$reclaim_pool_gentle, exe$gs_npp_npool, 0);
}

---