Movatterモバイル変換

[0]ホーム
URL:

Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly

 Sign up
Appearance settings

Commit3a1c761

Browse files
committed
catnapw: cleanup type annotations to reduce syntactic clutter
By removing unnecessary type annotations, semantics are popping outbetter than before.
1 parent9d6e064 commit3a1c761

File tree

5 files changed

+140
-150
lines changed

5 files changed

+140
-150
lines changed

‎src/catnap/win/error.rs

Lines changed: 16 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -6,17 +6,14 @@
66
//======================================================================================================================
77

88
usecrate::runtime::fail::Fail;
9-
use windows::{
10-
core::HRESULT,
11-
Win32::{
12-
Foundation::{
13-
RtlNtStatusToDosError,ERROR_ABANDONED_WAIT_0,ERROR_ACCESS_DENIED,ERROR_ALREADY_EXISTS,
14-
ERROR_INSUFFICIENT_BUFFER,ERROR_INVALID_HANDLE,ERROR_INVALID_PARAMETER,ERROR_IO_INCOMPLETE,
15-
ERROR_IO_PENDING,ERROR_MORE_DATA,ERROR_NOT_ENOUGH_MEMORY,ERROR_OPERATION_ABORTED,ERROR_SUCCESS,
16-
NTSTATUS,STATUS_ABANDONED,STATUS_SUCCESS,STATUS_TIMEOUT,WAIT_IO_COMPLETION,WAIT_TIMEOUT,WIN32_ERROR,
17-
},
18-
Networking::WinSock::{self,WSAGetLastError,WSABASEERR,WSA_ERROR,WSA_IO_PENDING},
9+
use windows::Win32::{
10+
Foundation::{
11+
RtlNtStatusToDosError,ERROR_ABANDONED_WAIT_0,ERROR_ACCESS_DENIED,ERROR_ALREADY_EXISTS,
12+
ERROR_INSUFFICIENT_BUFFER,ERROR_INVALID_HANDLE,ERROR_INVALID_PARAMETER,ERROR_IO_INCOMPLETE,
13+
ERROR_IO_PENDING,ERROR_MORE_DATA,ERROR_NOT_ENOUGH_MEMORY,ERROR_OPERATION_ABORTED,ERROR_SUCCESS,NTSTATUS,
14+
STATUS_ABANDONED,STATUS_SUCCESS,STATUS_TIMEOUT,WAIT_IO_COMPLETION,WAIT_TIMEOUT,WIN32_ERROR,
1915
},
16+
Networking::WinSock::{self,WSAGetLastError,WSABASEERR,WSA_ERROR,WSA_IO_PENDING},
2017
};
2118

2219
//======================================================================================================================
@@ -25,8 +22,8 @@ use windows::{
2522

2623
implFail{
2724
pubfnfrom_win32_error(error:&windows::core::Error,is_wait_error:bool) ->Fail{
28-
let cause:String =format!("{}", error);
29-
let errno: libc::errno_t =matchWIN32_ERROR::from_error(error){
25+
let cause =format!("{}", error);
26+
let errno =matchWIN32_ERROR::from_error(error){
3027
Some(error) =>translate_win32_error(error, is_wait_error),
3128
None => libc::EFAULT,
3229
};
@@ -45,7 +42,7 @@ pub fn try_translate_win32_error(err: WIN32_ERROR, is_wait_api: bool) -> Option<
4542
constERROR_WAIT_TIMEOUT:WIN32_ERROR =WIN32_ERROR(WAIT_TIMEOUT.0);
4643
constERROR_WAIT_IO_COMPLETION:WIN32_ERROR =WIN32_ERROR(WAIT_IO_COMPLETION.0);
4744

48-
let errno: libc::errno_t =match err{
45+
let errno =match err{
4946
ERROR_ACCESS_DENIED => libc::EACCES,
5047
ERROR_NOT_ENOUGH_MEMORY => libc::ENOMEM,
5148
ERROR_ALREADY_EXISTS => libc::EEXIST,
@@ -83,7 +80,7 @@ pub fn try_translate_wsa_error(err: WSA_ERROR) -> Option<libc::errno_t> {
8380
returnNone;
8481
}
8582

86-
let value: libc::errno_t =match err{
83+
let value =match err{
8784
// Winsock errors with errno equivalents
8885
WinSock::WSAEINTR => libc::EINTR,
8986
WinSock::WSAEBADF => libc::EBADF,
@@ -195,18 +192,18 @@ pub fn translate_win32_error(error: WIN32_ERROR, is_wait_api: bool) -> libc::err
195192

196193
/// Translate a win32 error stored as a WSA_ERROR into a windows crate Error type.
197194
fnwsa_error_to_win_error(err:WSA_ERROR) -> windows::core::Error{
198-
let code:HRESULT =WIN32_ERROR(err.0asu32).into();
195+
let code =WIN32_ERROR(err.0asu32).into();
199196
windows::core::Error::from_hresult(code)
200197
}
201198

202199
/// Get the result of the most recent winsock overlapped operation, interpreting WSAGetLastError and handling
203200
/// IO_PENDING non-errors.
204201
pubfnlast_overlapped_wsa_error() ->Result<(),Fail>{
205-
let wsa_error:WSA_ERROR =unsafe{WSAGetLastError()};
202+
let wsa_error =unsafe{WSAGetLastError()};
206203
if wsa_error ==WSA_IO_PENDING{
207204
Ok(())
208205
}else{
209-
let error: windows::core::Error =wsa_error_to_win_error(wsa_error);
206+
let error =wsa_error_to_win_error(wsa_error);
210207
if error.code().is_ok(){
211208
Ok(())
212209
}else{
@@ -238,8 +235,8 @@ pub fn expect_last_wsa_error() -> Fail {
238235
/// Convert from WIN32_ERROR to Fail.
239236
implFrom<WIN32_ERROR>forFail{
240237
fnfrom(value:WIN32_ERROR) ->Self{
241-
let code:HRESULT = value.into();
242-
let error: windows::core::Error = windows::core::Error::from_hresult(code);
238+
let code = value.into();
239+
let error = windows::core::Error::from_hresult(code);
243240
error.into()
244241
}
245242
}

‎src/catnap/win/overlapped.rs

Lines changed: 41 additions & 43 deletions
Original file line numberDiff line numberDiff line change
@@ -81,7 +81,7 @@ impl OverlappedResult {
8181

8282
/// Convert the OverlappedResult into a Result<...> indicating success or failure of the referent operation.
8383
pubfnok(&self) ->Result<(),Fail>{
84-
let win32_error:WIN32_ERROR =translate_ntstatus(self.result);
84+
let win32_error =translate_ntstatus(self.result);
8585
if win32_error.is_ok(){
8686
Ok(())
8787
}else{
@@ -93,7 +93,7 @@ impl OverlappedResult {
9393
impl<S:Unpin>IoCompletionPort<S>{
9494
/// Create a new I/O completion port.
9595
pubfnnew() ->Result<IoCompletionPort<S>,Fail>{
96-
let iocp:HANDLE =matchunsafe{CreateIoCompletionPort(INVALID_HANDLE_VALUE,None,0,1)}{
96+
let iocp =matchunsafe{CreateIoCompletionPort(INVALID_HANDLE_VALUE,None,0,1)}{
9797
Ok(handle) => handle,
9898
Err(err) =>returnErr(err.into()),
9999
};
@@ -150,7 +150,7 @@ impl<S: Unpin> IoCompletionPort<S> {
150150
for<'a>F2:FnOnce(Pin<&'amutS>,OverlappedResult) ->Result<R,Fail>,
151151
{
152152
// Allocate a new Overlapped completion in the pin slab.
153-
let pinslab_index:usize =matchself.ops.insert(OverlappedCompletion::new(state)){
153+
let pinslab_index =matchself.ops.insert(OverlappedCompletion::new(state)){
154154
Some(index) => index,
155155
None =>{
156156
returnErr(Fail::new(
@@ -160,21 +160,20 @@ impl<S: Unpin> IoCompletionPort<S> {
160160
},
161161
};
162162
// Grab a reference to the new completion in the pin slab.
163-
letmut pinned_completion:Pin<&mutOverlappedCompletion<S>> =
164-
expect_some!(self.ops.get_pin_mut(pinslab_index),"Just inserted this");
163+
letmut pinned_completion =expect_some!(self.ops.get_pin_mut(pinslab_index),"Just inserted this");
165164

166165
// Set the pinslab index so the I/O processor can remove it later if necessary.
167166
pinned_completion.as_mut().set_pinslab_index(pinslab_index);
168167

169-
let overlapped:*mutOVERLAPPED = pinned_completion.as_mut().marshal();
170-
let result:Result<R,Fail> =matchstart(pinned_completion.as_mut().get_state(), overlapped){
168+
let overlapped = pinned_completion.as_mut().marshal();
169+
let result =matchstart(pinned_completion.as_mut().get_state(), overlapped){
171170
// Operation in progress, pending overlapped completion.
172171
Ok(()) =>{
173172
whileletSome(mut cv) = pinned_completion.as_ref().get_cv(){
174173
cv.wait().await;
175174
}
176175

177-
let overlapped_result:OverlappedResult =OverlappedResult::new(
176+
let overlapped_result =OverlappedResult::new(
178177
pinned_completion.as_mut().overlapped,
179178
pinned_completion.as_mut().completion_key,
180179
);
@@ -219,10 +218,10 @@ impl<S: Unpin> IoCompletionPort<S> {
219218
pubfnprocess_events(&mutself) ->Result<(),Fail>{
220219
// Arbitrarily chosen batch size; should be updated after tuning.
221220
constBATCH_SIZE:usize =4;
222-
letmut entries:[OVERLAPPED_ENTRY;BATCH_SIZE] =[OVERLAPPED_ENTRY::default();BATCH_SIZE];
221+
letmut entries =[OVERLAPPED_ENTRY::default();BATCH_SIZE];
223222

224223
loop{
225-
letmut dequeued:u32 =0;
224+
letmut dequeued =0;
226225
matchunsafe{GetQueuedCompletionStatusEx(self.iocp, entries.as_mut_slice(),&mut dequeued,0,FALSE)}{
227226
Ok(()) =>{
228227
for iin0..dequeued{
@@ -247,7 +246,7 @@ impl<S: Unpin> IoCompletionPort<S> {
247246

248247
impl<S:Unpin>OverlappedCompletion<S>{
249248
pubfnnew(state:S) ->Self{
250-
let cv:SharedConditionVariable =SharedConditionVariable::default();
249+
let cv =SharedConditionVariable::default();
251250

252251
Self{
253252
overlapped:OVERLAPPED::default(),
@@ -313,7 +312,7 @@ mod tests {
313312
usecrate::{
314313
ensure_eq,
315314
runtime::{conditional_yield_with_timeout,SharedDemiRuntime},
316-
OperationResult,QDesc,QToken,
315+
OperationResult,QDesc,
317316
};
318317
use futures::pin_mut;
319318
use std::{
@@ -425,7 +424,7 @@ mod tests {
425424

426425
#[test]
427426
fntest_marshal_unmarshal() ->Result<()>{
428-
letmut completion:Pin<Box<OverlappedCompletion<()>>> =Box::pin(OverlappedCompletion::new(()));
427+
letmut completion =Box::pin(OverlappedCompletion::new(()));
429428

430429
// Ensure that the marshal returns the address of the overlapped member.
431430
ensure_eq!(
@@ -445,8 +444,8 @@ mod tests {
445444
(completion.as_ref().get_ref()as*constOverlappedCompletion<()>)asusize
446445
);
447446

448-
let overlapped_ptr:NonNull<OVERLAPPED> =NonNull::new(completion.as_mut().marshal()).unwrap();
449-
let unmarshalled:Pin<&mutOverlappedCompletion<()>> =OverlappedCompletion::unmarshal(overlapped_ptr);
447+
let overlapped_ptr =NonNull::new(completion.as_mut().marshal()).unwrap();
448+
let unmarshalled =OverlappedCompletion::unmarshal(overlapped_ptr);
450449

451450
// Test that unmarshal returns an address which is the same as the OVERLAPPED, which is the same as the original
452451
// OverlappedCompletionWithState. This implies that OVERLAPPED is at member offset 0 in all structs.
@@ -463,19 +462,19 @@ mod tests {
463462
fntest_event_processor() ->Result<()>{
464463
constCOMPLETION_KEY:usize =123;
465464
letmut iocp:IoCompletionPort<()> =make_iocp()?;
466-
let overlapped:OverlappedCompletion<()> =OverlappedCompletion::new(());
467-
letmut cv:SharedConditionVariable = overlapped.condition_variable.clone().unwrap();
465+
let overlapped =OverlappedCompletion::new(());
466+
letmut cv = overlapped.condition_variable.clone().unwrap();
468467
pin_mut!(overlapped);
469468

470469
// Insert coroutine
471-
letmut runtime:SharedDemiRuntime =SharedDemiRuntime::default();
470+
letmut runtime =SharedDemiRuntime::default();
472471
let server =run_as_io_op(asyncmove{
473472
cv.wait().await;
474473
Ok(OperationResult::Close)
475474
})
476475
.fuse();
477476

478-
let server_task:QToken = runtime
477+
let server_task = runtime
479478
.insert_nonpolling_coroutine("ioc_server",Box::pin(server))
480479
.unwrap();
481480
post_completion(&iocp, overlapped.as_mut().marshal(),COMPLETION_KEY)?;
@@ -503,7 +502,7 @@ mod tests {
503502
constPIPE_NAME:PCSTR =s!(r"\\.\pipe\demikernel-test-pipe");
504503
constBUFFER_SIZE:u32 =128;
505504
constCOMPLETION_KEY:usize =0xFEEDF00D;
506-
let server_pipe:SafeHandle =SafeHandle(unsafe{
505+
let server_pipe =SafeHandle(unsafe{
507506
CreateNamedPipeA(
508507
PIPE_NAME,
509508
PIPE_ACCESS_DUPLEX |FILE_FLAG_FIRST_PIPE_INSTANCE |FILE_FLAG_OVERLAPPED,
@@ -515,11 +514,11 @@ mod tests {
515514
None,
516515
)
517516
}?);
518-
let server_state:Rc<AtomicU32> =Rc::new(AtomicU32::new(0));
519-
let server_state_view:Rc<AtomicU32> = server_state.clone();
520-
letmut iocp:UnsafeCell<IoCompletionPort<Rc<Vec<u8>>>> =UnsafeCell::new(make_iocp().map_err(anyhow_fail)?);
517+
let server_state =Rc::new(AtomicU32::new(0));
518+
let server_state_view = server_state.clone();
519+
letmut iocp =UnsafeCell::new(make_iocp().map_err(anyhow_fail)?);
521520
iocp.get_mut().associate_handle(server_pipe.0,COMPLETION_KEY)?;
522-
let iocp_ref:&mutIoCompletionPort<Rc<Vec<u8>>> =unsafe{&mut*iocp.get()};
521+
let iocp_ref =unsafe{&mut*iocp.get()};
523522

524523
let server =Box::pin(
525524
run_as_io_op(asyncmove{
@@ -537,13 +536,12 @@ mod tests {
537536

538537
server_state.fetch_add(1,Ordering::Relaxed);
539538

540-
letmut buffer:Rc<Vec<u8>> =
541-
Rc::new(iter::repeat(0u8).take(BUFFER_SIZEasusize).collect::<Vec<u8>>());
539+
letmut buffer =Rc::new(iter::repeat(0u8).take(BUFFER_SIZEasusize).collect::<Vec<u8>>());
542540
buffer =unsafe{
543541
iocp_ref.do_io(
544542
buffer,
545543
|state:Pin<&mutRc<Vec<u8>>>,overlapped:*mutOVERLAPPED| ->Result<(),Fail>{
546-
let vec:&mutVec<u8> =Rc::get_mut(state.get_mut()).unwrap();
544+
let vec =Rc::get_mut(state.get_mut()).unwrap();
547545
vec.resize(BUFFER_SIZEasusize,0u8);
548546
is_overlapped_ok(ReadFile(
549547
server_pipe.0,
@@ -572,10 +570,10 @@ mod tests {
572570
}
573571
.await?;
574572

575-
let message:&str = std::str::from_utf8(buffer.as_slice())
573+
let message = std::str::from_utf8(buffer.as_slice())
576574
.map_err(|_|Fail::new(libc::EINVAL,"utf8 conversion failed"))?;
577575
if message !=MESSAGE{
578-
let err_msg:String =format!("expected\"{}\", got\"{}\"",MESSAGE, message);
576+
let err_msg =format!("expected\"{}\", got\"{}\"",MESSAGE, message);
579577
Err(Fail::new(libc::EINVAL, err_msg.as_str()))
580578
}else{
581579
// Dummy result
@@ -585,8 +583,8 @@ mod tests {
585583
.fuse(),
586584
);
587585

588-
letmut runtime:SharedDemiRuntime =SharedDemiRuntime::default();
589-
let server_task:QToken = runtime.insert_nonpolling_coroutine("ioc_server", server).unwrap();
586+
letmut runtime =SharedDemiRuntime::default();
587+
let server_task = runtime.insert_nonpolling_coroutine("ioc_server", server).unwrap();
590588

591589
letmut wait_for_state = |state| ->Result<(),Fail>{
592590
while server_state_view.load(Ordering::Relaxed) < state{
@@ -604,7 +602,7 @@ mod tests {
604602

605603
wait_for_state(1)?;
606604

607-
let client_handle:SafeHandle =SafeHandle(unsafe{
605+
let client_handle =SafeHandle(unsafe{
608606
CreateFileA(
609607
PIPE_NAME,
610608
GENERIC_WRITE.0,
@@ -618,7 +616,7 @@ mod tests {
618616

619617
wait_for_state(2)?;
620618

621-
letmut bytes_written:u32 =0;
619+
letmut bytes_written =0;
622620
unsafe{
623621
WriteFile(
624622
client_handle.0,
@@ -630,7 +628,7 @@ mod tests {
630628

631629
std::mem::drop(client_handle);
632630

633-
let result:OperationResult =loop{
631+
let result =loop{
634632
iocp.get_mut().process_events()?;
635633
ifletOk((_, result)) = runtime.wait(server_task,Duration::ZERO){
636634
break result;
@@ -650,7 +648,7 @@ mod tests {
650648
constPIPE_NAME:PCSTR =s!(r"\\.\pipe\demikernel-test-cancel-pipe");
651649
constBUFFER_SIZE:u32 =128;
652650
constCOMPLETION_KEY:usize =0xFEEDF00D;
653-
let server_pipe:SafeHandle =SafeHandle(unsafe{
651+
let server_pipe =SafeHandle(unsafe{
654652
CreateNamedPipeA(
655653
PIPE_NAME,
656654
PIPE_ACCESS_DUPLEX |FILE_FLAG_FIRST_PIPE_INSTANCE |FILE_FLAG_OVERLAPPED,
@@ -662,11 +660,11 @@ mod tests {
662660
None,
663661
)
664662
}?);
665-
let server_state:Rc<AtomicU32> =Rc::new(AtomicU32::new(0));
666-
let server_state_view:Rc<AtomicU32> = server_state.clone();
667-
letmut iocp:UnsafeCell<IoCompletionPort<()>> =UnsafeCell::new(make_iocp().map_err(anyhow_fail)?);
663+
let server_state =Rc::new(AtomicU32::new(0));
664+
let server_state_view = server_state.clone();
665+
letmut iocp =UnsafeCell::new(make_iocp().map_err(anyhow_fail)?);
668666
iocp.get_mut().associate_handle(server_pipe.0,COMPLETION_KEY)?;
669-
let iocp_ref:&mutIoCompletionPort<()> =unsafe{&mut*iocp.get()};
667+
let iocp_ref =unsafe{&mut*iocp.get()};
670668

671669
let server =run_as_io_op(asyncmove{
672670
matchconditional_yield_with_timeout(
@@ -690,8 +688,8 @@ mod tests {
690688
})
691689
.fuse();
692690

693-
letmut runtime:SharedDemiRuntime =SharedDemiRuntime::default();
694-
let server_task:QToken = runtime
691+
letmut runtime =SharedDemiRuntime::default();
692+
let server_task = runtime
695693
.insert_nonpolling_coroutine("ioc_server",Box::pin(server))
696694
.unwrap();
697695

@@ -701,11 +699,11 @@ mod tests {
701699
"server execution should have started"
702700
);
703701

704-
let iocp_ref:&mutIoCompletionPort<()> =unsafe{&mut*iocp.get()};
702+
let iocp_ref =unsafe{&mut*iocp.get()};
705703
iocp_ref.process_events()?;
706704

707705
// Poll the runtime again, which
708-
let result:OperationResult =loop{
706+
let result =loop{
709707
// Move time forward, which should time out the operation.
710708
runtime.advance_clock(Instant::now());
711709
iocp.get_mut().process_events()?;

0 commit comments

Comments
 (0)
[8]ページ先頭
©2009-2025 Movatter.jp