aboutsummaryrefslogtreecommitdiffstats
path: root/src/scripts/vnet/virl
diff options
context:
space:
mode:
authorKlement Sekera <ksekera@cisco.com>2021-12-03 10:48:13 +0000
committerKlement Sekera <ksekera@cisco.com>2021-12-03 10:51:11 +0000
commit5d5f85f5e4003476fb6d9a0ccd6ad58ad90e5138 (patch)
treeb1f30e5bc4de1610badc00093d33ee88ca058336 /src/scripts/vnet/virl
parent03092c1982468ff6ffe260b0215f910d4c486b04 (diff)
api: refactor to use REPLY_MSG_ID_BASE #define
REPLY_MSG_ID_BASE is the standard way to define reply message id base, so this refactor makes all the files use that. This is a preparation patch for future safety add-ons which rely on REPLY_MACRO* parameters to be preprocessor tokens identifying the message instead, Type: refactor Signed-off-by: Klement Sekera <ksekera@cisco.com> Change-Id: Ibe3e056a3d9326d08af45bbcb25588b11e870141
Diffstat (limited to 'src/scripts/vnet/virl')
0 files changed, 0 insertions, 0 deletions
href='#n146'>146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 
/*
 * Copyright (c) 2018 Cisco and/or its affiliates.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at:
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <vppinfra/valloc.h>

u32
vl (void *p)
{
  return vec_len (p);
}

/*
 * GDB callable function: pe - call pool_elts - number of elements in a pool
 */
uword
pe (void *v)
{
  return (pool_elts (v));
}

typedef struct
{
  u32 seed;
  uword baseva;
  uword size;
  uword *basevas;
  u8 *item_in_table;
  u32 nitems;
  u32 niter;
  u32 item_size;
  int check_every_add_del;
  clib_valloc_main_t valloc_main;
  int verbose;
} test_main_t;

test_main_t test_main;

clib_error_t *
test_valloc (test_main_t * tm)
{
  clib_valloc_chunk_t _ip, *ip = &_ip;
  uword baseva;
  uword *p;
  int i, j, index;
  u32 currently_in_table;
  u32 found;

  ip->baseva = 0x20000000;
  ip->size = 1024;

  clib_valloc_init (&tm->valloc_main, ip, 1 /* lock */ );

  ip->baseva = 0x20000000 + 1024;
  ip->size = 1024 * 1024 * 1024 - 1024;
  clib_valloc_add_chunk (&tm->valloc_main, ip);

  fformat (stdout, "Allocate %d items...\n", tm->nitems);
  for (i = 0; i < tm->nitems; i++)
    {
      baseva = clib_valloc_alloc (&tm->valloc_main, 1024,
				  1 /* fail:os_out_of_memory */ );
      vec_add1 (tm->basevas, baseva);
      vec_add1 (tm->item_in_table, 1);
    }

  fformat (stdout, "Perform %d random add/delete operations...\n", tm->niter);

  for (i = 0; i < tm->niter; i++)
    {
      index = random_u32 (&tm->seed) % tm->nitems;
      /* Swap state of random entry */
      if (tm->item_in_table[index])
	{
	  if (0)
	    fformat (stdout, "free [%d] %llx\n", index, tm->basevas[index]);
	  clib_valloc_free (&tm->valloc_main, tm->basevas[index]);
	  tm->item_in_table[index] = 0;
	  tm->basevas[index] = ~0;
	}
      else
	{
	  baseva = clib_valloc_alloc (&tm->valloc_main, 1024,
				      1 /* fail:os_out_of_memory */ );
	  tm->basevas[index] = baseva;
	  tm->item_in_table[index] = 1;
	  if (0)
	    fformat (stdout, "alloc [%d] %llx\n", index, tm->basevas[index]);
	}

      /* Check our work... */
      if (tm->check_every_add_del)
	{
	  for (j = 0; j < tm->nitems; j++)
	    {
	      if (tm->item_in_table[j])
		{
		  p = hash_get ((&tm->valloc_main)->chunk_index_by_baseva,
				tm->basevas[j]);
		  if (p)
		    {
		      ip =
			pool_elt_at_index ((&tm->valloc_main)->chunks, p[0]);
		      ASSERT (ip->baseva == tm->basevas[j]);
		      ASSERT (ip->flags & CLIB_VALLOC_BUSY);
		    }
		}
	      else
		{
		  p = hash_get ((&tm->valloc_main)->chunk_index_by_baseva,
				tm->basevas[j]);
		  /* Have to check, it's OK for the block to have been fused */
		  if (p)
		    {
		      ip =
			pool_elt_at_index ((&tm->valloc_main)->chunks, p[0]);
		      if ((ip->flags & CLIB_VALLOC_BUSY))
			{
			  fformat (stdout, "BUG: baseva %llx chunk %d busy\n",
				   tm->basevas[j], p[0]);
			  fformat (stdout, "%U\n", format_valloc,
				   &tm->valloc_main, 1 /* verbose */ );
			  ASSERT ((ip->flags & CLIB_VALLOC_BUSY) == 0);
			}
		    }
		}
	    }
	}
    }

  currently_in_table = 0;

  for (i = 0; i < tm->nitems; i++)
    {
      currently_in_table += tm->item_in_table[i];
    }

  fformat (stdout, "Check that %d items in table can be found...\n",
	   currently_in_table);

  found = 0;

  for (i = 0; i < tm->nitems; i++)
    {
      if (tm->item_in_table[i])
	{
	  p = hash_get ((&tm->valloc_main)->chunk_index_by_baseva,
			tm->basevas[i]);
	  if (p)
	    {
	      ip = pool_elt_at_index ((&tm->valloc_main)->chunks, p[0]);
	      ASSERT (ip->baseva == tm->basevas[i]);
	      ASSERT (ip->flags & CLIB_VALLOC_BUSY);
	    }
	  found++;
	}
      else
	{
	  p = hash_get ((&tm->valloc_main)->chunk_index_by_baseva,
			tm->basevas[i]);
	  /* Have to check, it's OK for the block to have been fused */
	  if (p)
	    {
	      ip = pool_elt_at_index ((&tm->valloc_main)->chunks, p[0]);
	      if ((ip->flags & CLIB_VALLOC_BUSY))
		{
		  fformat (stdout, "BUG: baseva %llx chunk %d busy\n",
			   tm->basevas[i], p[0]);
		  fformat (stdout, "%U\n", format_valloc,
			   &tm->valloc_main, 1 /* verbose */ );
		  ASSERT ((ip->flags & CLIB_VALLOC_BUSY) == 0);
		}
	    }
	}
    }

  fformat (stdout, "Found %d items in table...\n", found);

  for (i = 0; i < tm->nitems; i++)
    {
      if (tm->item_in_table[i])
	clib_valloc_free (&tm->valloc_main, tm->basevas[i]);
    }

  fformat (stdout, "%U", format_valloc, &tm->valloc_main, 1 /* verbose */ );

  return 0;
}

clib_error_t *
test_valloc_main (unformat_input_t * i)
{
  test_main_t *tm = &test_main;
  clib_error_t *error;

  tm->seed = 0xdeaddabe;
  tm->nitems = 5;
  tm->niter = 100;
  tm->item_size = 1024;

  while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
    {
      if (unformat (i, "seed %u", &tm->seed))
	;
      else if (unformat (i, "nitems %u", &tm->nitems))
	;
      else if (unformat (i, "niter %u", &tm->niter))
	;
      else if (unformat (i, "item-size %u", &tm->item_size))
	;
      else if (unformat (i, "check-every-add-del"))
	tm->check_every_add_del = 1;
      else if (unformat (i, "verbose %d", &tm->verbose))
	;
      else if (unformat (i, "verbose"))
	tm->verbose = 1;
      else
	return clib_error_return (0, "unknown input '%U'",
				  format_unformat_error, i);
    }

  error = test_valloc (tm);

  return error;
}

#ifdef CLIB_UNIX
int
main (int argc, char *argv[])
{
  unformat_input_t i;
  int rv = 0;
  clib_error_t *error;

  clib_mem_init (0, 3ULL << 30);

  unformat_init_command_line (&i, argv);
  error = test_valloc_main (&i);
  if (error)
    {
      clib_error_report (error);
      rv = 1;
    }
  unformat_free (&i);

  return rv;
}
#endif /* CLIB_UNIX */

/*
 * fd.io coding-style-patch-verification: ON
 *
 * Local Variables:
 * eval: (c-set-style "gnu")
 * End:
 */