8358095 · streamly · git.iko.soy

git.iko.soy/streamly

on master help sign in

Use NOINLINE on some benchmarks

8358095Harendra Kumar6 years ago

benchmark/Streamly/Benchmark/FileSystem/Handle/ReadWrite.hs+16

compare with master

unifiedsplit

@@ -338,6 +338,7 @@ o_1_space_copy_fromBytes env =

338 ]

339

340-- | Send the file contents ('defaultChunkSize') to /dev/null

341+{-# NOINLINE writeReadWithBufferOf #-}

341writeReadWithBufferOf :: Handle -> Handle -> IO ()

342writeReadWithBufferOf :: Handle -> Handle -> IO ()

342writeReadWithBufferOf inh devNull = IUF.fold unf fld (defaultChunkSize, inh)

343writeReadWithBufferOf inh devNull = IUF.fold unf fld (defaultChunkSize, inh)

343

344

@@ -355,6 +356,7 @@ inspect $ 'writeReadWithBufferOf `hasNoType` ''AT.ArrayUnsafe -- FH.write/writeN

355#endif

356#endif

356

357

357-- | Send the file contents ('AT.defaultChunkSize') to /dev/null

358-- | Send the file contents ('AT.defaultChunkSize') to /dev/null

359+{-# NOINLINE writeRead #-}

358writeRead :: Handle -> Handle -> IO ()

360writeRead :: Handle -> Handle -> IO ()

359writeRead inh devNull = IUF.fold unf fld inh

361writeRead inh devNull = IUF.fold unf fld inh

360

362

@@ -386,6 +388,7 @@ o_1_space_copy env =

386-------------------------------------------------------------------------------

388-------------------------------------------------------------------------------

387

389

388-- | Send the file contents to /dev/null with exception handling

390-- | Send the file contents to /dev/null with exception handling

391+{-# NOINLINE readWriteOnExceptionUnfold #-}

389readWriteOnExceptionUnfold :: Handle -> Handle -> IO ()

392readWriteOnExceptionUnfold :: Handle -> Handle -> IO ()

390readWriteOnExceptionUnfold inh devNull =

393readWriteOnExceptionUnfold inh devNull =

391 let readEx = IUF.onException (\_ -> hClose inh) FH.read

394 let readEx = IUF.onException (\_ -> hClose inh) FH.read

@@ -397,6 +400,7 @@ inspect $ hasNoTypeClasses 'readWriteOnExceptionUnfold

397#endif

400#endif

398

401

399-- | Send the file contents to /dev/null with exception handling

402-- | Send the file contents to /dev/null with exception handling

403+{-# NOINLINE readWriteHandleExceptionUnfold #-}

400readWriteHandleExceptionUnfold :: Handle -> Handle -> IO ()

404readWriteHandleExceptionUnfold :: Handle -> Handle -> IO ()

401readWriteHandleExceptionUnfold inh devNull =

405readWriteHandleExceptionUnfold inh devNull =

402 let handler (_e :: SomeException) = hClose inh >> return 10

406 let handler (_e :: SomeException) = hClose inh >> return 10

@@ -409,6 +413,7 @@ inspect $ hasNoTypeClasses 'readWriteHandleExceptionUnfold

409#endif

413#endif

410

414

411-- | Send the file contents to /dev/null with exception handling

415-- | Send the file contents to /dev/null with exception handling

416+{-# NOINLINE readWriteFinally_Unfold #-}

412readWriteFinally_Unfold :: Handle -> Handle -> IO ()

417readWriteFinally_Unfold :: Handle -> Handle -> IO ()

413readWriteFinally_Unfold inh devNull =

418readWriteFinally_Unfold inh devNull =

414 let readEx = IUF.finally_ (\_ -> hClose inh) FH.read

419 let readEx = IUF.finally_ (\_ -> hClose inh) FH.read

@@ -419,12 +424,14 @@ inspect $ hasNoTypeClasses 'readWriteFinally_Unfold

419-- inspect $ 'readWriteFinallyUnfold `hasNoType` ''Step

424-- inspect $ 'readWriteFinallyUnfold `hasNoType` ''Step

420#endif

425#endif

421

426

427+{-# NOINLINE readWriteFinallyUnfold #-}

422readWriteFinallyUnfold :: Handle -> Handle -> IO ()

428readWriteFinallyUnfold :: Handle -> Handle -> IO ()

423readWriteFinallyUnfold inh devNull =

429readWriteFinallyUnfold inh devNull =

424 let readEx = IUF.finally (\_ -> hClose inh) FH.read

430 let readEx = IUF.finally (\_ -> hClose inh) FH.read

425 in S.fold (FH.write devNull) $ S.unfold readEx inh

431 in S.fold (FH.write devNull) $ S.unfold readEx inh

426

432

427-- | Send the file contents to /dev/null with exception handling

433-- | Send the file contents to /dev/null with exception handling

434+{-# NOINLINE readWriteBracket_Unfold #-}

428readWriteBracket_Unfold :: Handle -> Handle -> IO ()

435readWriteBracket_Unfold :: Handle -> Handle -> IO ()

429readWriteBracket_Unfold inh devNull =

436readWriteBracket_Unfold inh devNull =

430 let readEx = IUF.bracket_ return (\_ -> hClose inh) FH.read

437 let readEx = IUF.bracket_ return (\_ -> hClose inh) FH.read

@@ -435,6 +442,7 @@ inspect $ hasNoTypeClasses 'readWriteBracket_Unfold

435-- inspect $ 'readWriteBracketUnfold `hasNoType` ''Step

442-- inspect $ 'readWriteBracketUnfold `hasNoType` ''Step

436#endif

443#endif

437

444

445+{-# NOINLINE readWriteBracketUnfold #-}

438readWriteBracketUnfold :: Handle -> Handle -> IO ()

446readWriteBracketUnfold :: Handle -> Handle -> IO ()

439readWriteBracketUnfold inh devNull =

447readWriteBracketUnfold inh devNull =

440 let readEx = IUF.bracket return (\_ -> hClose inh) FH.read

448 let readEx = IUF.bracket return (\_ -> hClose inh) FH.read

@@ -463,12 +471,14 @@ o_1_space_copy_read_exceptions env =

463-------------------------------------------------------------------------------

471-------------------------------------------------------------------------------

464

472

465-- | Send the file contents to /dev/null with exception handling

473-- | Send the file contents to /dev/null with exception handling

474+{-# NOINLINE readWriteOnExceptionStream #-}

466readWriteOnExceptionStream :: Handle -> Handle -> IO ()

475readWriteOnExceptionStream :: Handle -> Handle -> IO ()

467readWriteOnExceptionStream inh devNull =

476readWriteOnExceptionStream inh devNull =

468 let readEx = S.onException (hClose inh) (S.unfold FH.read inh)

477 let readEx = S.onException (hClose inh) (S.unfold FH.read inh)

469 in S.fold (FH.write devNull) $ readEx

478 in S.fold (FH.write devNull) $ readEx

470

479

471-- | Send the file contents to /dev/null with exception handling

480-- | Send the file contents to /dev/null with exception handling

481+{-# NOINLINE readWriteHandleExceptionStream #-}

472readWriteHandleExceptionStream :: Handle -> Handle -> IO ()

482readWriteHandleExceptionStream :: Handle -> Handle -> IO ()

473readWriteHandleExceptionStream inh devNull =

483readWriteHandleExceptionStream inh devNull =

474 let handler (_e :: SomeException) = S.yieldM (hClose inh >> return 10)

484 let handler (_e :: SomeException) = S.yieldM (hClose inh >> return 10)

@@ -476,11 +486,13 @@ readWriteHandleExceptionStream inh devNull =

476 in S.fold (FH.write devNull) $ readEx

486 in S.fold (FH.write devNull) $ readEx

477

487

478-- | Send the file contents to /dev/null with exception handling

488-- | Send the file contents to /dev/null with exception handling

489+{-# NOINLINE readWriteFinally_Stream #-}

479readWriteFinally_Stream :: Handle -> Handle -> IO ()

490readWriteFinally_Stream :: Handle -> Handle -> IO ()

480readWriteFinally_Stream inh devNull =

491readWriteFinally_Stream inh devNull =

481 let readEx = IP.finally_ (hClose inh) (S.unfold FH.read inh)

492 let readEx = IP.finally_ (hClose inh) (S.unfold FH.read inh)

482 in S.fold (FH.write devNull) readEx

493 in S.fold (FH.write devNull) readEx

483

494

495+{-# NOINLINE readWriteFinallyStream #-}

484readWriteFinallyStream :: Handle -> Handle -> IO ()

496readWriteFinallyStream :: Handle -> Handle -> IO ()

485readWriteFinallyStream inh devNull =

497readWriteFinallyStream inh devNull =

486 let readEx = S.finally (hClose inh) (S.unfold FH.read inh)

498 let readEx = S.finally (hClose inh) (S.unfold FH.read inh)

@@ -504,6 +516,7 @@ fromToBytesBracketStream inh devNull =

504 (\_ -> IFH.toBytes inh)

516 (\_ -> IFH.toBytes inh)

505 in IFH.fromBytes devNull $ readEx

517 in IFH.fromBytes devNull $ readEx

506

518

519+{-# NOINLINE readWriteBeforeAfterStream #-}

507readWriteBeforeAfterStream :: Handle -> Handle -> IO ()

520readWriteBeforeAfterStream :: Handle -> Handle -> IO ()

508readWriteBeforeAfterStream inh devNull =

521readWriteBeforeAfterStream inh devNull =

509 let readEx =

522 let readEx =

@@ -511,11 +524,13 @@ readWriteBeforeAfterStream inh devNull =

511 $ IP.before (hPutChar devNull 'A') (S.unfold FH.read inh)

524 $ IP.before (hPutChar devNull 'A') (S.unfold FH.read inh)

512 in S.fold (FH.write devNull) readEx

525 in S.fold (FH.write devNull) readEx

513

526

527+{-# NOINLINE readWriteAfterStream #-}

514readWriteAfterStream :: Handle -> Handle -> IO ()

528readWriteAfterStream :: Handle -> Handle -> IO ()

515readWriteAfterStream inh devNull =

529readWriteAfterStream inh devNull =

516 let readEx = IP.after (hClose inh) (S.unfold FH.read inh)

530 let readEx = IP.after (hClose inh) (S.unfold FH.read inh)

517 in S.fold (FH.write devNull) readEx

531 in S.fold (FH.write devNull) readEx

518

532

533+{-# NOINLINE readWriteAfter_Stream #-}

519readWriteAfter_Stream :: Handle -> Handle -> IO ()

534readWriteAfter_Stream :: Handle -> Handle -> IO ()

520readWriteAfter_Stream inh devNull =

535readWriteAfter_Stream inh devNull =

521 let readEx = IP.after_ (hClose inh) (S.unfold FH.read inh)

536 let readEx = IP.after_ (hClose inh) (S.unfold FH.read inh)

@@ -674,6 +689,7 @@ wordsUnwordsCopy inh outh =

674-- inspect $ 'wordsUnwordsCopy `hasNoType` ''Step

689-- inspect $ 'wordsUnwordsCopy `hasNoType` ''Step

675#endif

690#endif

676

691

692+{-# NOINLINE wordsUnwordsCharArrayCopy #-}

677wordsUnwordsCharArrayCopy :: Handle -> Handle -> IO ()

693wordsUnwordsCharArrayCopy :: Handle -> Handle -> IO ()

678wordsUnwordsCharArrayCopy inh outh =

694wordsUnwordsCharArrayCopy inh outh =

679 S.fold (FH.write outh)

695 S.fold (FH.write outh)