~drizzle-trunk/drizzle/development

printf("%7s %5s %9s %5s %9s %5s ", f->fi_monitor_name, f->fi_monitor_name, f->fi_monitor_name, f->fi_monitor_name, f->fi_monitor_name, f->fi_monitor_name);

268

}

269

}

270

printf("\n");

271

printf(" ");

272

for (i=0; i<MAX_FILES; i++) {

273

if ((f = monitor_files[i])) {

274

printf("%7s %5s %9s %5s %9s %5s ", "flush", "ftime", "write", "wtime", "read", "rtime");

275

}

276

}

277

printf("\n");

278

}

279

280

static void *iotest_monitor(void *data)

281

{

282

File *f;

283

int i;

284

int row = 0;

285

my_time curr, last;

286

my_time now, fstart, wstart, rstart;

287

int version = 0;

288

int activity;

289

290

my_time curr_flush_time;

291

u_long curr_flush_count;

292

my_time curr_write_time;

293

u_long curr_write_count;

294

my_time curr_read_time;

295

u_long curr_read_count;

296

297

my_time flush_time;

298

u_long flush_count;

299

my_time write_time;

300

u_long write_count;

301

my_time read_time;

302

u_long read_count;

303

304

monitor_running = TRUE;

305

last = my_clock();

306

for (;;) {

307

curr = my_clock();

308

309

if (!monitor_files_in_use)

310

goto wait_phase;

311

312

if ((row % 20) == 0 || version != monitor_file_count) {

313

version = monitor_file_count;

314

print_header();

315

}

316

317

printf("%4.0f ", ((double) curr - (double) last) / (double) 1000);

318

activity = FALSE;

319

for (i=0; i<MAX_FILES; i++) {

320

if ((f = monitor_files[i])) {

321

curr_flush_time = f->flush_time;

322

fstart = f->flush_start;

323

curr_write_time = f->write_time;

324

wstart = f->write_start;

325

curr_read_time = f->read_time;

326

rstart = f->read_start;

327

now = my_clock();

328

329

if (fstart)

330

curr_flush_time += now - fstart;

331

flush_time = curr_flush_time - f->last_flush_time;

332

f->last_flush_time = curr_flush_time;

333

334

curr_flush_count = f->flush_count;

335

flush_count = curr_flush_count - f->last_flush_count;

336

f->last_flush_count = curr_flush_count;

337

338

if (wstart)

339

curr_write_time += now - wstart;

340

write_time = curr_write_time - f->last_write_time;

341

f->last_write_time = curr_write_time;

342

343

curr_write_count = f->write_count;

344

write_count = curr_write_count - f->last_write_count;

345

f->last_write_count = curr_write_count;

346

347

if (rstart)

348

curr_read_time += now - rstart;

349

read_time = curr_read_time - f->last_read_time;

350

f->last_read_time = curr_read_time;

351

352

curr_read_count = f->read_count;

353

read_count = curr_read_count - f->last_read_count;

354

f->last_read_count = curr_read_count;

355

356

printf("%7lu %5.0f %9.2f %5.0f %9.2f %5.0f ", flush_count, (double) flush_time / (double) 1000,

357

(double) write_count / (double) 1024, (double) write_time / (double) 1000,

358

(double) read_count / (double) 1024, (double) read_time / (double) 1000);

359

if (flush_count || flush_time || write_count || write_time || read_count || read_time) {

360

f->fi_monitor_active = TRUE;

361

activity = TRUE;

362

}

363

else

364

f->fi_monitor_active = FALSE;

365

}

366

}

367

printf("\n");

368

row++;

369

370

wait_phase:

371

372

/* Leave the loop, only when there is no more activity. */

373

if (!monitor_running && !activity)

374

break;

375

376

do {

377

usleep(1000);

378

} while (my_clock() - curr < 1000000);

379

last = curr;

380

}

381

382

return NULL;

383

}

384

385

/* ------------------- BASIC FILE I/O ------------------- */

386

387

#define PREFILL 0

388

#define SET_EOF 1

389

#define TRUNCATE 2

390

391

#define XT_MASK ((S_IRUSR | S_IWUSR) | (S_IRGRP | S_IWGRP) | (S_IROTH))

392

393

static void create_file(File *f, size_t size, int type)

394

{

395

int fd;

396

size_t tfer;

397

char *block;

398

size_t i;

399

off_t eof;

400

off_t offset;

401

402

if (!(block = (char *) malloc(512)))

403

error_exit(f->fi_file_path, errno);

404

for (i=0; i<512; i++)

405

block[i] = (char) i;

406

407

fd = open(f->fi_file_path, O_CREAT | O_RDWR, XT_MASK);

408

if (fd == -1)

409

error_exit(f->fi_file_path, errno);

410

411

eof = lseek(fd, 0, SEEK_END);

412

if (type == PREFILL && size == eof)

413

goto done;

414

415

if (ftruncate(fd, 0) == -1)

416

error_exit(f->fi_file_path, errno);

417

418

if (type == SET_EOF) {

419

if (size > 512)

420

offset = size - 512;

421

else

422

offset = 0;

423

if (pwrite(fd, block, 512, offset) != 512)

424

error_exit(f->fi_file_path, errno);

425

}

426

else {

427

offset = 0;

428

while (size > 0) {

429

tfer = size;

430

if (tfer > 512)

431

tfer = 512;

432

if (pwrite(fd, block, tfer, offset) != tfer)

433

error_exit(f->fi_file_path, errno);

434

size -= tfer;

435

offset += tfer;

436

}

437

}

438

439

if (fsync(fd) == -1)

440

error_exit(f->fi_file_path, errno);

441

442

done:

443

close(fd);

444

free(block);

445

}

446

447

448

static void delete_file(char *file)

449

{

450

unlink(file);

451

}

452

453

454

static void write_file(File *f, void *block, size_t size, off_t offset)

455

{

456

my_time t, s;

457

458

s = my_clock();

459

f->write_start = s;

460

if (pwrite(f->file_fh, block, size, offset) != size)

461

error_exit(f->fi_file_path, errno);

462

t = my_clock();

463

f->write_start = 0;

464

f->write_time += (t - s);

465

f->write_count += size;

466

467

/* Does this block touch the previous block? */

468

if (f->last_block_offset == -1 ||

469

offset < f->last_block_offset ||

470

offset > f->last_block_offset + f->last_block_size)

471

/* If not, it is a new block (with a gap): */

472

f->block_write_count++;

473

f->last_block_offset = offset;

474

f->last_block_size = size;

475

}

476

477

static void read_file(File *f, void *block, size_t size, off_t start)

478

{

479

my_time t, s;

480

481

s = my_clock();

482

f->read_start = s;

483

if (pread(f->file_fh, block, size, start) != size)

484

error_exit(f->fi_file_path, errno);

485

t = my_clock();

486

f->read_start = 0;

487

f->read_time += (t - s);

488

f->read_count += size;

489

}

490

491

static void sync_file(File *f)

492

{

493

my_time t, s;

494

495

s = my_clock();

496

f->flush_start = s;

497

if (fsync(f->file_fh) == -1)

498

error_exit(f->fi_file_path, errno);

499

t = my_clock();

500

f->flush_start = 0;

501

f->flush_time += t - s;

502

f->flush_count++;

503

}

504

505

static void new_file(File **ret_f, const char *test_name, const char *monitor_name)

506

{

507

File *f;

508

509

f = malloc(sizeof(File));

510

memset(f, 0, sizeof(File));

511

f->last_block_offset = (off_t) -1;

512

f->rs_min_block_offset = (off_t) -1;

513

514

monitor_file(f, test_name, monitor_name);

515

f->fi_write = write_file;

516

f->fi_sync = sync_file;

517

518

*ret_f = f;

519

}

520

521

static void open_file(File *f)

522

{

523

f->file_fh = open(f->fi_file_path, O_RDWR, 0);

524

if (f->file_fh == -1)

525

error_exit(f->fi_file_path, errno);

526

527

f->total_time = my_clock();

528

}

529

530

static void close_file(File *f)

531

{

532

f->fi_sync(f);

533

f->total_time = my_clock() - f->total_time;

534

if (f->file_fh != -1)

535

close(f->file_fh);

536

537

unmonitor_file(f);

538

539

printf("\n=* TEST: %s (%s) *=\n", f->fi_test_name, f->fi_monitor_name);

540

printf("Written K: %.2f\n", (double) f->write_count / (double) 1024);

541

printf("Run time: %.2f ms\n", (double) f->total_time / (double) 1000);

542

if (f->rs_flush_block_total > 0)

543

printf("Flush blks: %lu\n", f->rs_flush_block_total);

544

if (f->write_count > 0) {

545

printf("Tot blocks: %lu\n", f->block_write_count);

546

printf("Seek time: %.3f ms\n", (double) f->flush_time / (double) f->block_write_count / (double) 1000);

547

}

548

printf("\n");

549

if (f->write_time)

550

printf("Write K/s: %.2f\n", (double) f->write_count * (double) 1000000 / (double) 1024 / (double) f->write_time);

551

if (f->read_time)

552

printf("Read K/s: %.2f\n", (double) f->read_count * (double) 1000000 / (double) 1024 / (double) f->read_time);

553

if (f->flush_time)

554

printf("Flush K/s: %.2f\n", (double) f->write_count * (double) 1000000 / (double) 1024 / (double) f->flush_time);

555

if (f->write_time + f->read_time + f->flush_time)

556

printf("Total K/s: %.2f\n", (double) f->write_count * (double) 1000000 / (double) 1024 / ((double) f->write_time + (double) f->read_time + (double) f->flush_time));

557

printf("=*=\n");

558

}

559

560

/* ------------------- SORTED I/O ------------------- */

561

562

/* Sort records before they are writing.

563

* Options are also added to write records,

564

* in large blocks. This requires reading the block

565

* first.

566

567

568

static int compare_rec(const void *a, const void *b)

569

{

570

SortedRec *ra = (SortedRec *) a;

571

SortedRec *rb = (SortedRec *) b;

572

573

if (ra->sr_offset == rb->sr_offset) {

574

if (ra->sr_order == rb->sr_order)

575

return 0;

576

if (ra->sr_order < rb->sr_order)

577

return -1;

578

return 1;

579

}

580

if (ra->sr_offset < rb->sr_offset)

581

return -1;

582

return 1;

583

}

584

585

static void sorted_write_all(File *f)

586

{

587

SortedRec *rec;

588

int i;

589

590

qsort(f->sf_records, f->sf_rec_count, sizeof(SortedRec), compare_rec);

591

rec = f->sf_records;

592

for (i=0; i<f->sf_rec_count; i++) {

593

write_file(f, rec->sr_data, SIM_RECORD_SIZE, rec->sr_offset);

594

rec++;

595

}

596

597

f->sf_rec_count = 0;

598

f->sf_alloc_pos = 0;

599

f->sf_order = 0;

600

}

601

602

static void sorted_write_rw_all(File *f)

603

{

604

SortedRec *rec;

605

int i;

606

off_t offset = 0;

607

size_t size = 0;

608

609

qsort(f->sf_records, f->sf_rec_count, sizeof(SortedRec), compare_rec);

610

rec = f->sf_records;

611

for (i=0; i<f->sf_rec_count; i++) {

612

reread:

613

if (!size) {

614

offset = (rec->sr_offset / 1024) * 1024;

615

size = SORTED_BUFFER_SIZE;

616

if (offset+(off_t)size > SIM_FILE_SIZE)

617

size = (size_t) (SIM_FILE_SIZE - offset);

618

read_file(f, f->sf_buffer, size, offset);

619

}

620

621

if (rec->sr_offset >= offset && rec->sr_offset+SIM_RECORD_SIZE <= offset+size)

622

memcpy(&f->sf_buffer[rec->sr_offset - offset], rec->sr_data, SIM_RECORD_SIZE);

623

else {

624

write_file(f, f->sf_buffer, size, offset);

625

size = 0;

626

goto reread;

627

}

628

rec++;

629

}

630

631

f->sf_rec_count = 0;

632

f->sf_alloc_pos = 0;

633

f->sf_order = 0;

634

}

635

636

static void sorted_write_rw_no_gaps_all(File *f)

637

{

638

SortedRec *rec;

639

int i;

640

off_t offset;

641

size_t size = 0;

642

643

qsort(f->sf_records, f->sf_rec_count, sizeof(SortedRec), compare_rec);

644

rec = f->sf_records;

645

if (!f->sf_rec_count)

646

goto done;

647

648

offset = (rec->sr_offset / 1024) * 1024;

649

for (i=0; i<f->sf_rec_count; i++) {

650

reread:

651

if (!size) {

652

size = SORTED_BUFFER_SIZE;

653

if (offset+size > SIM_FILE_SIZE)

654

size = SIM_FILE_SIZE - offset;

655

read_file(f, f->sf_buffer, size, offset);

656

}

657

658

if (rec->sr_offset >= offset && rec->sr_offset+SIM_RECORD_SIZE <= offset+size)

659

memcpy(&f->sf_buffer[rec->sr_offset - offset], rec->sr_data, SIM_RECORD_SIZE);

660

else {

661

write_file(f, f->sf_buffer, size, offset);

662

offset += size;

663

if (rec->sr_offset < offset)

664

offset = (rec->sr_offset / 1024) * 1024;

665

size = 0;

666

goto reread;

667

}

668

rec++;

669

}

670

671

done:

672

f->sf_rec_count = 0;

673

f->sf_alloc_pos = 0;

674

f->sf_order = 0;

675

}

676

677

static void sorted_sync_file(File *f)

678

{

679

f->fi_write_all(f);

680

sync_file(f);

681

}

682

683

static void sorted_write_file(File *f, void *block, size_t size, off_t offset)

684

{

685

SortedRec *rec;

686

687

if (size != SIM_RECORD_SIZE)

688

printf("ooops\n");

689

690

if (f->sf_rec_count == SORTED_MAX_RECORDS ||

691

f->sf_alloc_pos + size > SORTED_DATA_SIZE) {

692

f->fi_write_all(f);

693

}

694

695

rec = &f->sf_records[f->sf_rec_count];

696

rec->sr_offset = offset;

697

rec->sr_order = f->sf_order;

698

rec->sr_data = &f->sf_data[f->sf_alloc_pos];

699

memcpy(rec->sr_data, block, size);

700

f->sf_alloc_pos += size;

701

f->sf_rec_count++;

702

f->sf_order++;

703

}

704

705

/* ------------------- RE-WRITE FLUSH ------------------- */

706

707

/* The idea is that it is better to re-write the file

708

* sequentially, then allow the FS to write scattered

709

* dirty blocks!

710

711

* This comes from the fact that seeking is a lot more

712

* expensive than sequential write.

713

714

715

static void rewrite_all_sync_file(File *f)

716

{

717

off_t offset = 0;

718

size_t size = 0;

719

720

while (offset < SIM_FILE_SIZE) {

721

size = SORTED_BUFFER_SIZE;

722

if (offset + size > SIM_FILE_SIZE)

723

size = SIM_FILE_SIZE - offset;

724

read_file(f, f->sf_buffer, size, offset);

725

write_file(f, f->sf_buffer, size, offset);

726

offset += size;

727

}

728

729

sync_file(f);

730

}

731

732

static void rewrite_min_max_sync_file(File *f)

733

{

734

off_t offset = 0;

735

size_t size = 0;

736

off_t eof = SIM_FILE_SIZE;

737

738

if (f->rs_min_block_offset != (off_t) -1)

739

offset = f->rs_min_block_offset / 1024 * 1024;

740

eof = (f->rs_max_block_offset + 1023) / 1024 * 1024;

741

if (eof > SIM_FILE_SIZE)

742

eof = SIM_FILE_SIZE;

743

while (offset < eof) {

744

size = SORTED_BUFFER_SIZE;

745

if (offset + size > eof)

746

size = eof - offset;

747

read_file(f, f->sf_buffer, size, offset);

748

write_file(f, f->sf_buffer, size, offset);

749

offset += size;

750

}

751

752

sync_file(f);

753

}

754

755

static void rewrite_min_max_write_file(File *f, void *block, size_t size, off_t offset)

756

{

757

off_t top_offset;

758

759

write_file(f, block, size, offset);

760

761

/* Round up and down by 1K */

762

top_offset = offset + size;

763

offset = offset / 1024 * 1024;

764

top_offset = (top_offset + 1023) / 1024 * 1024;

765

size = (size_t) (top_offset - offset);

766

767

/* Calculate max and min and max offset: */

768

if (f->rs_min_block_offset == (off_t) -1 || offset < f->rs_min_block_offset)

769

f->rs_min_block_offset = offset;

770

if (offset + size > f->rs_max_block_offset)

771

f->rs_max_block_offset = offset + size;

772

}

773

774

static void rewrite_opt_rewrite_file(File *f)

775

{

776

RewriteRec *rec;

777

int i;

778

off_t offset;

779

off_t size;

780

size_t tfer;

781

782

/* Re-write all areas written: */

783

rec = f->rs_records;

784

for (i=0; i<f->rs_rec_count; i++) {

785

size = rec->rr_size;

786

offset = rec->rr_offset;

787

while (size) {

788

tfer = SORTED_BUFFER_SIZE;

789

if ((off_t) tfer > size)

790

tfer = size;

791

read_file(f, f->sf_buffer, tfer, offset);

792

write_file(f, f->sf_buffer, tfer, offset);

793

offset += tfer;

794

size -= tfer;

795

}

796

rec++;

797

}

798

799

f->rs_flush_block_total += f->rs_rec_count;

800

f->rs_rec_count = 0;

801

}

802

803

static int rewrite_opt_comp(void *k, void *r)

804

{

805

806

807

808

if (*key == rec->rr_offset)

809

return 0;

810

if (*key < rec->rr_offset)

811

return -1;

812

return 1;

813

}

814

815

static void rewrite_opt_sync_file(File *f)

816

{

817

rewrite_opt_rewrite_file(f);

818

sync_file(f);

819

}

820

821

static void rewrite_opt_write_file(File *f, void *block, size_t size, off_t offset)

822

{

823

RewriteRec *rec;

824

size_t idx;

825

off_t top_offset;

826

827

write_file(f, block, size, offset);

828

829

/* Round up and down by 1K */

830

top_offset = offset + size;

831

offset = offset / 1024 * 1024;

832

top_offset = (top_offset + 1023) / 1024 * 1024;

833

size = (size_t) (top_offset - offset);

834

835

if ((rec = my_bsearch(&offset, f->rs_records, f->rs_rec_count, sizeof(RewriteRec), &idx, rewrite_opt_comp))) {

836

if ((off_t) size > rec->rr_size)

837

rec->rr_size = size;

838

goto merge_right;

839

}

840

841

if (idx == 0) {

842

/* The offset is before the first entry. */

843

if (idx < f->rs_rec_count) {

844

/* There is a first entry: */

845

rec = f->rs_records;

846

if (rec->rr_offset - (offset + size) < REWRITE_BLOCK_DISTANCE)

847

goto add_to_right;

848

}

849

850

/* Add the first entry: */

851

goto add_the_entry;

852

}

853

854

/* Not the first entry: */

855

idx--;

856

rec = f->rs_records + idx;

857

858

if (offset - (rec->rr_offset + rec->rr_size) < REWRITE_BLOCK_DISTANCE) {

859

/* Add to block on left: */

860

size = (offset + size) - rec->rr_offset;

861

if (size > rec->rr_size)

862

rec->rr_size = size;

863

goto merge_right;

864

}

865

866

idx++;

867

rec = f->rs_records + idx;

868

869

if (idx < f->rs_rec_count && rec->rr_offset - (offset + size) < REWRITE_BLOCK_DISTANCE)

870

goto add_to_right;

871

872

add_the_entry:

873

if (f->rs_rec_count == REWRITE_MAX_RECORDS) {

874

rewrite_opt_rewrite_file(f);

875

idx = 0;

876

}

877

rec = f->rs_records + idx;

878

memmove(rec+1, rec, (f->rs_rec_count - idx) * sizeof(RewriteRec));

879

rec->rr_offset = offset;

880

rec->rr_size = (off_t) size;

881

f->rs_rec_count++;

882

return;

883

884

add_to_right:

885

rec->rr_size += rec->rr_offset - offset;

886

if (size > rec->rr_size)

887

rec->rr_size = size;

888

rec->rr_offset = offset;

889

890

merge_right:

891

if (idx+1 < f->rs_rec_count) {

892

/* There is a record right: */

893

if (rec->rr_offset + rec->rr_size + REWRITE_BLOCK_DISTANCE > (rec+1)->rr_offset) {

894

/* Merge and remove! */

895

size = (rec+1)->rr_size + ((rec+1)->rr_offset - rec->rr_offset);

896

if (size > rec->rr_size)

897

rec->rr_size = size;

898

f->rs_rec_count--;

899

assert(f->rs_rec_count > idx);

900

memmove(rec+1, rec+2, (f->rs_rec_count - idx - 1) * sizeof(RewriteRec));

901

}

902

}

903

return;

904

905

}

906

907

static void rewrite_limit_sync_file(File *f)

908

{

909

rewrite_opt_rewrite_file(f);

910

sync_file(f);

911

}

912

913

914

* This options is like opt but it limits the number of

915

* blocks that can be written.

916

917

static void rewrite_limit_write_file(File *f, void *block, size_t size, off_t offset)

918

{

919

RewriteRec *rec;

920

921

/* There must always be room for one more: */

922

assert(f->rs_rec_count < REWRITE_RECORD_LIMIT);

923

rewrite_opt_write_file(f, block, size, offset);

924

if (f->rs_rec_count == REWRITE_RECORD_LIMIT) {

925

/* Consolidate 2 blocks that are closest to each other in other to

926

* make space for another block:

927

928

int i, idx;

929

off_t gap;

930

off_t min_gap = (off_t) -1;

931

932

rec = f->rs_records;

933

for (i=0; i<f->rs_rec_count-1; i++) {

934

gap = (rec+1)->rr_offset - (rec->rr_offset + rec->rr_size);

935

if (min_gap == (off_t) -1 || gap < min_gap) {

936

idx = i;

937

min_gap = gap;

938

}

939

rec++;

940

}

941

942

/* Merge this with the next: */

943

rec = f->rs_records + idx;

944

size = (rec+1)->rr_size + ((rec+1)->rr_offset - rec->rr_offset);

945

if (size > rec->rr_size)

946

rec->rr_size = size;

947

f->rs_rec_count--;

948

assert(f->rs_rec_count > idx);

949

memmove(rec+1, rec+2, (f->rs_rec_count - idx - 1) * sizeof(RewriteRec));

950

}

951

}

952

953

/* ------------------- SIMULATION I/O ------------------- */

954

955

956

static void random_read_bytes(File *f, off_t file_size, size_t size, size_t count, int print)

957

{

958

char *block;

959

size_t i;

960

off_t offset;

961

long x = (long) (file_size / (off_t) size), y;

962

963

block = (char *) malloc(size);

964

965

for (i=0; i<count; i++) {

966

y = random() % x;

967

offset = (off_t) y * (off_t) size;

968

if (offset+size > file_size) {

969

printf("NOOO\n");

970

exit(1);

971

}

972

read_file(f, block, size, offset);

973

if (print) {

974

if ((i%100) == 0)

975

printf("%ld\n", (long) i);

976

}

977

}

978

free(block);

979

}

980

981

982

static void read_write_bytes(File *f, off_t file_size)

983

{

984

off_t offset = 0;

985

size_t tfer;

986

987

while (file_size > 0) {

988

tfer = SORTED_BUFFER_SIZE;

989

if ((off_t) tfer > file_size)

990

tfer = (size_t) file_size;

991

read_file(f, f->sf_buffer, tfer, offset);

992

f->fi_write(f, f->sf_buffer, tfer, offset);

993

offset += tfer;

994

file_size -= tfer;

995

}

996

}

997

998

static void random_write_bytes(File *f, off_t file_size, size_t size, off_t amount_to_write, int sync_after, int pause_after)

999

{

1000

char *block;

1001

off_t offset;

1002

long x = (long) (file_size / (off_t) size), y;

1003

long pbytes_written = 0;

1004

long sbytes_written = 0;

1005

off_t total_written = 0;

1006

int i;

1007

1008

block = (char *) malloc(size);

1009

for (i=0; i<size; i++)

1010

block[i] = (char) i;

1011

1012

if (pause_after) {

1013

pbytes_written = 0;

1014

sleep(10);

1015

}

1016

while (total_written < amount_to_write) {

1017

y = random() % x;

1018

do {

1019

offset = (off_t) y * (off_t) size;

1020

}

1021

while (offset+size > file_size);

1022

f->fi_write(f, block, size, offset);

1023

sbytes_written += size;

1024

pbytes_written += size;

1025

total_written += size;

1026

if (sync_after && sbytes_written > sync_after) {

1027

sbytes_written = 0;

1028

f->fi_sync(f);

1029

}

1030

if (pause_after && pbytes_written > pause_after) {

1031

pbytes_written = 0;

1032

sleep(10);

1033

}

1034

}

1035

free(block);

1036

}

1037

1038

static void seq_write_bytes(File *f, off_t file_size, size_t size, off_t amount_to_write, int sync_after, int pause_after)

1039

{

1040

char *block;

1041

off_t offset;

1042

long pbytes_written = 0;

1043

long sbytes_written = 0;

1044

off_t total_written = 0;

1045

int i;

1046

1047

block = (char *) malloc(size);

1048

for (i=0; i<size; i++)

1049

block[i] = (char) i;

1050

1051

if (pause_after) {

1052

pbytes_written = 0;

1053

sleep(10);

1054

}

1055

offset = 0;

1056

while (total_written < amount_to_write) {

1057

if (offset+size > file_size)

1058

offset = 0;

1059

f->fi_write(f, block, size, offset);

1060

sbytes_written += size;

1061

pbytes_written += size;

1062

total_written += size;

1063

offset += size;

1064

if (sync_after && sbytes_written > sync_after) {

1065

sbytes_written = 0;

1066

f->fi_sync(f);

1067

}

1068

if (pause_after && pbytes_written > pause_after) {

1069

pbytes_written = 0;

1070

sleep(10);

1071

}

1072

}

1073

free(block);

1074

}

1075

1076

static void simulate_xlog_write(File *f, off_t eof, off_t start_point, size_t size, off_t amount_to_write)

1077

{

1078

char *block;

1079

off_t start = start_point;

1080

off_t offset;

1081

size_t tfer;

1082

off_t total_written = 0;

1083

int i;

1084

1085

block = (char *) malloc(1024*16);

1086

for (i=0; i<1024*16; i++)

1087

block[i] = (char) i;

1088

1089

while (total_written < amount_to_write) {

1090

/* Write 512 byte boundary block around random data we wish to write. */

1091

offset = (start / 512) * 512;

1092

tfer = (((start + size) / 512) * 512 + 512) - offset;

1093

f->fi_write(f, block, tfer, offset);

1094

total_written += tfer;

1095

f->fi_sync(f);

1096

start += size;

1097

if (start + size > eof)

1098

start = start_point;

1099

}

1100

1101

free(block);

1102

}

1103

1104

static void seq_write_blocks_aligned(File *f, off_t file_size, size_t block_size, off_t amount_to_write)

1105

{

1106

char *block;

1107

off_t i, no_of_writes;

1108

off_t offset, inc;

1109

1110

/* Blocks, 1 K in size: */

1111

block_size = block_size / 1024 * 1024;

1112

1113

block = (char *) malloc(block_size);

1114

for (i=0; i<block_size; i++)

1115

block[i] = (char) i;

1116

1117

no_of_writes = amount_to_write / block_size;

1118

1119

/* Calculate and round increment: */

1120

inc = (file_size / no_of_writes) / 1024 * 1024;

1121

1122

/* This is required if we want a gap: */

1123

assert(inc > block_size);

1124

1125

offset = 0;

1126

for (i=0; i<no_of_writes; i++) {

1127

f->fi_write(f, block, block_size, offset);

1128

offset += inc;

1129

}

1130

}

1131

1132

/* ------------------- TESTS ------------------- */

1133

1134

static void *test_xlog_write_prealloc(void *data)

1135

{

1136

File *f;

1137

1138

new_file(&f, __FUNCTION__, "xlog");

1139

create_file(f, SIM_FILE_SIZE, PREFILL);

1140

open_file(f);

1141

simulate_xlog_write(f, SIM_FILE_SIZE, 0, SIM_RECORD_SIZE, SIM_WRITE_AMOUNT);

1142

close_file(f);

1143

return NULL;

1144

}

1145

1146

static void *test_xlog_write_no_prealloc(void *data)

1147

{

1148

File *f;

1149

1150

new_file(&f, __FUNCTION__, "xlog");

1151

create_file(f, 512, TRUNCATE);

1152

open_file(f);

1153

simulate_xlog_write(f, SIM_FILE_SIZE, 0, SIM_RECORD_SIZE, SIM_WRITE_AMOUNT);

1154

close_file(f);

1155

return NULL;

1156

}

1157

1158

static void *test_xlog_write_set_eof(void *data)

1159

{

1160

File *f;

1161

1162

new_file(&f, __FUNCTION__, "xlog");

1163

create_file(f, SIM_FILE_SIZE, SET_EOF);

1164

open_file(f);

1165

simulate_xlog_write(f, SIM_FILE_SIZE, 0, SIM_RECORD_SIZE, SIM_WRITE_AMOUNT);

1166

close_file(f);

1167

return NULL;

1168

}

1169

1170

static void *test_rnd_write_prealloc(void *data)

1171

{

1172

File *f;

1173

1174

new_file(&f, __FUNCTION__, "rndw");

1175

create_file(f, SIM_FILE_SIZE, PREFILL);

1176

open_file(f);

1177

random_write_bytes(f, SIM_FILE_SIZE, SIM_RECORD_SIZE, SIM_WRITE_AMOUNT, SIM_FLUSH_THRESHOLD, SIM_PAUSE_THRESHOLD);

1178

close_file(f);

1179

return NULL;

1180

}

1181

1182

static void *test_rnd_write_no_prealloc(void *data)

1183

{

1184

File *f;

1185

1186

new_file(&f, __FUNCTION__, "rndw");

1187

create_file(f, 0, TRUNCATE);

1188

open_file(f);

1189

random_write_bytes(f, SIM_FILE_SIZE, SIM_RECORD_SIZE, SIM_WRITE_AMOUNT, SIM_FLUSH_THRESHOLD, SIM_PAUSE_THRESHOLD);

1190

close_file(f);

1191

return NULL;

1192

}

1193

1194

static void *test_rnd_write_rewrite_all_sync_prealloc(void *data)

1195

{

1196

File *f;

1197

1198

new_file(&f, __FUNCTION__, "rndw");

1199

create_file(f, SIM_FILE_SIZE, PREFILL);

1200

open_file(f);

1201

f->fi_sync = rewrite_all_sync_file;

1202

random_write_bytes(f, SIM_FILE_SIZE, SIM_RECORD_SIZE, SIM_WRITE_AMOUNT, SIM_FLUSH_THRESHOLD, SIM_PAUSE_THRESHOLD);

1203

close_file(f);

1204

return NULL;

1205

}

1206

1207

static void *test_rnd_write_rewrite_min_max_sync_prealloc(void *data)

1208

{

1209

File *f;

1210

1211

new_file(&f, __FUNCTION__, "rndw");

1212

create_file(f, SIM_FILE_SIZE, PREFILL);

1213

open_file(f);

1214

f->fi_write = rewrite_min_max_write_file;

1215

f->fi_sync = rewrite_min_max_sync_file;

1216

random_write_bytes(f, SIM_FILE_SIZE, SIM_RECORD_SIZE, SIM_WRITE_AMOUNT, SIM_FLUSH_THRESHOLD, SIM_PAUSE_THRESHOLD);

1217

close_file(f);

1218

return NULL;

1219

}

1220

1221

static void *test_rnd_write_rewrite_opt_sync_prealloc(void *data)

1222

{

1223

File *f;

1224

1225

new_file(&f, __FUNCTION__, "rndw");

1226

create_file(f, SIM_FILE_SIZE, PREFILL);

1227

open_file(f);

1228

f->fi_write = rewrite_opt_write_file;

1229

f->fi_sync = rewrite_opt_sync_file;

1230

random_write_bytes(f, SIM_FILE_SIZE, SIM_RECORD_SIZE, SIM_WRITE_AMOUNT, SIM_FLUSH_THRESHOLD, SIM_PAUSE_THRESHOLD);

1231

close_file(f);

1232

return NULL;

1233

}

1234

1235

static void *test_rnd_write_rewrite_limit_sync_prealloc(void *data)

1236

{

1237

File *f;

1238

1239

new_file(&f, __FUNCTION__, "rndw");

1240

create_file(f, SIM_FILE_SIZE, PREFILL);

1241

open_file(f);

1242

f->fi_write = rewrite_limit_write_file;

1243

f->fi_sync = rewrite_limit_sync_file;

1244

random_write_bytes(f, SIM_FILE_SIZE, SIM_RECORD_SIZE, SIM_WRITE_AMOUNT, SIM_FLUSH_THRESHOLD, SIM_PAUSE_THRESHOLD);

1245

close_file(f);

1246

return NULL;

1247

}

1248

1249

static void *test_rnd_write_sorted_prealloc(void *data)

1250

{

1251

File *f;

1252

1253

new_file(&f, __FUNCTION__, "rndsw");

1254

create_file(f, SIM_FILE_SIZE, PREFILL);

1255

open_file(f);

1256

f->fi_write = sorted_write_file;

1257

f->fi_sync = sorted_sync_file;

1258

f->fi_write_all = sorted_write_all;

1259

f->fi_write_all = sorted_write_rw_all;

1260

f->fi_write_all = sorted_write_rw_no_gaps_all;

1261

random_write_bytes(f, SIM_FILE_SIZE, SIM_RECORD_SIZE, SIM_WRITE_AMOUNT, SIM_FLUSH_THRESHOLD, SIM_PAUSE_THRESHOLD);

1262

close_file(f);

1263

return NULL;

1264

}

1265

1266

static void *test_seq_write_prealloc(void *data)

1267

{

1268

File *f;

1269

1270

new_file(&f, __FUNCTION__, "seqw");

1271

create_file(f, SIM_FILE_SIZE, PREFILL);

1272

open_file(f);

1273

seq_write_bytes(f, SIM_FILE_SIZE, SIM_RECORD_SIZE, SIM_WRITE_AMOUNT, SIM_FLUSH_THRESHOLD, SIM_PAUSE_THRESHOLD);

1274

close_file(f);

1275

return NULL;

1276

}

1277

1278

static void *test_seq_write_no_prealloc(void *data)

1279

{

1280

File *f;

1281

1282

new_file(&f, __FUNCTION__, "seqw");

1283

create_file(f, 0, TRUNCATE);

1284

open_file(f);

1285

seq_write_bytes(f, SIM_FILE_SIZE, SIM_RECORD_SIZE, SIM_WRITE_AMOUNT, SIM_FLUSH_THRESHOLD, SIM_PAUSE_THRESHOLD);

1286

close_file(f);

1287

return NULL;

1288

}

1289

1290

static void *test_seq_rw_prealloc(void *data)

1291

{

1292

File *f;

1293

1294

new_file(&f, __FUNCTION__, "seqrw");

1295

create_file(f, SIM_FILE_SIZE, PREFILL);

1296

open_file(f);

1297

read_write_bytes(f, SIM_FILE_SIZE);

1298

close_file(f);

1299

return NULL;

1300

}

1301

1302

int block_write_block_count = 128;

1303

1304

static void *test_block_write_aligned_prealloc(void *data)

1305

{

1306

File *f;

1307

off_t write_amount = SIM_FILE_SIZE / 2;

1308

1309

new_file(&f, __FUNCTION__, "block");

1310

create_file(f, SIM_FILE_SIZE, PREFILL);

1311

open_file(f);

1312

seq_write_blocks_aligned(f, SIM_FILE_SIZE, write_amount / block_write_block_count, write_amount);

1313

close_file(f);

1314

return NULL;

1315

}

1316

1317

/* ------------------- THREADING ------------------- */

1318

1319

static pthread_t run_task_as_thread(void *(*task)(void *))

1320

{

1321

pthread_t thread;

1322

int err;

1323

1324

err = pthread_create(&thread, NULL, task, NULL);

1325

if (err)

1326

error_exit("pthread_create", err);

1327

return thread;

1328

}

1329

1330

static void wait_for_task(pthread_t thread)

1331

{

1332

void *value;

1333

1334

pthread_join(thread, &value);

1335

}

1336

1337

/* ------------------- MAIN ------------------- */

1338

1339

static void reference_tests()

1340

{

1341

test_xlog_write_prealloc(NULL);

1342

test_xlog_write_no_prealloc(NULL);

1343

test_xlog_write_set_eof(NULL);

1344

1345

test_rnd_write_prealloc(NULL);

1346

test_rnd_write_no_prealloc(NULL);

1347

test_rnd_write_rewrite_all_sync_prealloc(NULL);

1348

test_rnd_write_rewrite_min_max_sync_prealloc(NULL);

1349

test_rnd_write_rewrite_opt_sync_prealloc(NULL);

1350

test_rnd_write_rewrite_limit_sync_prealloc(NULL);

1351

1352

test_rnd_write_sorted_prealloc(NULL);

1353

1354

test_seq_write_prealloc(NULL);

1355

test_seq_write_no_prealloc(NULL);

1356

test_seq_rw_prealloc(NULL);

1357

1358

test_block_write_aligned_prealloc(NULL);

1359

}

1360

1361

static void do_task(void *(*task)(void *))

1362

{

1363

pthread_t t1;

1364

t1 = run_task_as_thread(task);

1365

wait_for_task(t1);

1366

}

1367

1368

static void do_test_1()

1369

{

1370

pthread_t t1;

1371

//pthread_t t2;

1372

1373

t1 = run_task_as_thread(test_rnd_write_sorted_prealloc);

1374

//t2 = run_task_as_thread(test_xlog_write_prealloc);

1375

1376

wait_for_task(t1);

1377

//wait_for_task(t2);

1378

}

1379

1380

static void do_test_2()

1381

{

1382

//do_task(test_rnd_write_prealloc);

1383

//do_task(test_rnd_write_rewrite_min_max_sync_prealloc);

1384

do_task(test_rnd_write_rewrite_limit_sync_prealloc);

1385

1386

1387

block_write_block_count = 1;

1388

do_task(test_block_write_aligned_prealloc);

1389

block_write_block_count = 2;

1390

do_task(test_block_write_aligned_prealloc);

1391

block_write_block_count = 4;

1392

do_task(test_block_write_aligned_prealloc);

1393

block_write_block_count = 8;

1394

do_task(test_block_write_aligned_prealloc);

1395

block_write_block_count = 16;

1396

do_task(test_block_write_aligned_prealloc);

1397

block_write_block_count = 32;

1398

do_task(test_block_write_aligned_prealloc);

1399

block_write_block_count = 64;

1400

do_task(test_block_write_aligned_prealloc);

1401

block_write_block_count = 128;

1402

do_task(test_block_write_aligned_prealloc);

1403

1404

}

1405

1406

int main(int argc, char **argv)

1407

{

1408

//pthread_t m;

1409

1410

//m = run_task_as_thread(iotest_monitor);

1411

1412

do_test_2();

1413

1414

monitor_running = FALSE;

1415

//wait_for_task(m);

1416

return 0;

1417

}

Older »